0:\n #pathbin1c = \"C:\\\\Program Files\\\\1cv82\\8.2.17.153\\\\bin\\\\1cv8.exe\"\n #pathbin1c = \"c:\\\\Program Files (x86)\\\\1cv8\\\\8.3.4.304\\\\bin\\\\1cv8.exe\"\n pathbin1c = get_path_to_1c()\n\n if len(dataprocessor_files_v7) > 0:\n for filename in dataprocessor_files_v7:\n print(\"ert file %s\" % filename)\n #TODO: добавить копирование этих же файлов в каталог src/имяфайла/...\n #get file name.\n fullpathfile = os.path.abspath(filename)\n basename = os.path.splitext(os.path.basename(filename))[0]\n fullbasename = os.path.basename(filename)\n newdirname = os.path.dirname(filename)\n\n print(\"ert file %s\" % fullpathfile )\n\n #Скопируем сначало просто структуру каталогов.\n if not os.path.exists(dirsource):\n os.makedirs(dirsource)\n #для каждого файла определим новую папку.\n newsourcepath = os.path.join(dirsource, newdirname)\n newpath2 = os.path.join(newsourcepath, basename)\n if not os.path.exists(newsourcepath):\n logging.info(\"create new dir %s\" % newsourcepath)\n os.makedirs(newsourcepath)\n #print(\"curabsdirpath %s\" % curabsdirpath)\n #print(\"newpath2 %s\" % newpath2)\n #print(\"basename %s\" % basename)\n\n t1 = format(\"gcomp -q -d -F %s -D %s -v --no-ini --no-version --no-empty-mxl\" % (filename, newsourcepath))\n result = subprocess.check_call(['cmd.exe', '/C', t1]) \n #изменим кодировку cp1251 на utf-8 \n #утилита iconv.exe должна запускаться в cmd = добавлена в PATH\t\t\t\n #файлов 1s, mdp, frm, txt\n t3 = 'bash .git/hooks/convert_utf8.sh {0}'.format( newpath2 )\n print(\"t3 = %s\" % t3)\n logging.info(\"CONVERT: %s\" % t3)\n result = subprocess.check_call(['cmd.exe', '/C', t3])\n #result = subprocess.check_call(['git', 'add', '--all', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.1s', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.frm', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.mxl', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.utf', newsourcepath])\n if not result == 0:\n logging.error(result)\n exit(result)\n\n if len(dataprocessor_files_MD) > 0:\n for filename in dataprocessor_files_MD:\n print(\"MD file %s\" % filename)\n #TODO: добавить копирование этих же файлов в каталог src/имяфайла/...\n #get file name.\n fullpathfile = os.path.abspath(filename)\n basename = os.path.splitext(os.path.basename(filename))[0]\n fullbasename = os.path.basename(filename)\n newdirname = os.path.dirname(filename)\n \n #Скопируем сначало просто структуру каталогов.\n if not os.path.exists(dirsource):\n os.makedirs(dirsource)\n #для каждого файла определим новую папку.\n newsourcepath = os.path.join(dirsource, newdirname, \"MD\")\n if not os.path.exists(newsourcepath):\n logging.info(\"create new dir %s\" % newsourcepath)\n os.makedirs(newsourcepath)\n newpath2 = os.path.join(newsourcepath, basename)\n print(\"fullbasename %s\" % fullbasename)\n print(\"newdirname %s\" % newdirname)\n print(\"newsourcepath %s\" % newsourcepath)\n \n t1 = format(\"gcomp -d -v -F %s -D %s\" % (filename, newsourcepath))\n result = subprocess.check_call(['cmd.exe', '/C', t1])\n\n #изменим кодировку cp1251 на utf-8 \n #утилита iconv.exe должна запускаться в cmd = добавлена в PATH\t\t\t\n #файлов 1s, mdp, frm, txt\n t3 = 'bash .git/hooks/convert_utf8.sh {0}'.format( newsourcepath )\n print(\"t3 = %s\" % t3)\n logging.info(\"CONVERT: %s\" % t3)\n result = subprocess.check_call(['cmd.exe', '/C', t3])\n\n #result = subprocess.check_call(['git', 'add', '--all', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.1s', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.frm', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.mxl', newsourcepath])\n result = subprocess.check_call(['git', 'add', '*.utf', newsourcepath])\n if not result == 0:\n logging.error(result)\n exit(result)","def build(ctx):\n generate_build_files(ctx)\n compile_build_files(ctx)\n _package_plugins(ctx)","def cosmic_compile(c_file_path, logger=init_console_logger(name=\"cosmic_compile\")):\n # checks\n assert(os.path.isfile(c_file_path))\n assert(\".c\" == c_file_path[-2:])\n logger.info(\"Compiling...\")\n\n # clean old header files\n logger.info(\"Cleaning old header files...\")\n previous_h_files = [_ for _ in os.listdir(CRAM_DIR_PATH) if _[-2:] == \".h\"]\n for f in previous_h_files:\n try:\n os.remove(os.path.join(CRAM_DIR_PATH, f))\n except Exception as e:\n logger.warning(\"Failed to clean old header files: '{}' could not be deleted: {}\".format(f, e))\n\n # collect source header files\n with open(c_file_path, \"r\") as f:\n lines = f.read()\n local_includes = re.findall(r\"#include\\s{0,1}\\\".+[^\\s]\\\"\", lines)\n h_filenames = [_[8:].replace('\"', '').replace(' ', '') for _ in local_includes]\n\n # copy source header files\n source_dir_path = os.path.join(os.path.dirname(c_file_path))\n for h_filename in h_filenames:\n src = os.path.join(source_dir_path, h_filename)\n dst = os.path.join(CRAM_DIR_PATH, h_filename)\n try:\n logger.info(\"Copying header file '{}' to '{}' ...\".format(src, dst))\n shutil.copyfile(src, dst)\n except IOError as e:\n logger.error(\"Header file '{}' was not found. Compilation failed. Error message: {}\".format(h_filename, e))\n logger.error(\"Compilation failed\")\n return\n\n # compile\n command = r'\"{}\" \"{}\" \"{}\"'.format(COMPILE_BAT_PATH, CRAM_DIR_PATH, c_file_path)\n logger.debug(\"Executing command: {}\".format(command))\n p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\n std_reader = io.TextIOWrapper(p.stdout, encoding='utf8')\n err_reader = io.TextIOWrapper(p.stderr, encoding='utf8')\n\n while True:\n # read outputs\n s_out = std_reader.readline().rstrip()\n e_out = err_reader.readline().rstrip()\n\n # output std output text\n if s_out != '':\n logger.info(s_out)\n\n # error occurred\n elif e_out != '':\n # output entire error then return 1\n while e_out != '':\n logger.error(e_out)\n e_out = err_reader.readline().rstrip()\n logger.error(\"Compilation failed\")\n return 1\n\n # process finished\n elif p.poll() is not None:\n logger.info(\"Compilation successful\")\n return 0","def build(obj):\n\n err = False\n\n if obj.portable:\n chdir(obj.python_bin_path)\n # Setup build process\n process = subprocess.Popen(\n obj.params,\n stdout=subprocess.PIPE,\n stderr=subprocess.STDOUT,\n shell=False\n )\n\n # Kick off build process\n print \"Building %s...\" % obj.app\n print \"Please be patient; this might take a while.\\nResults and/or errors will be posted when complete.\"\n output = process.communicate()\n\n # Check for bad error code\n if process.returncode:\n print >> sys.stderr, \"Compilation failed!\"\n err = True\n\n # Display output\n print output[0]\n\n return err","def build_apple(arch: str, debug: bool = False) -> None:\n import platform\n import subprocess\n from efro.error import CleanError\n\n # IMPORTANT; seems we currently wind up building against /usr/local gettext\n # stuff. Hopefully the maintainer fixes this, but for now I need to\n # remind myself to blow it away while building.\n if 'MacBook-Fro' in platform.node():\n if (subprocess.run('which gettext', shell=True,\n check=False).returncode == 0):\n raise CleanError('NEED TO TEMP-KILL GETTEXT')\n\n builddir = 'build/python_apple_' + arch + ('_debug' if debug else '')\n efrotools.run('rm -rf \"' + builddir + '\"')\n efrotools.run('mkdir -p build')\n efrotools.run('git clone '\n 'git@github.com:pybee/Python-Apple-support.git \"' +\n builddir + '\"')\n os.chdir(builddir)\n\n # TEMP: Check out a particular commit while the branch head is broken.\n # We can actually fix this to use the current one, but something\n # broke in the underlying build even on old commits so keeping it\n # locked for now...\n # efrotools.run('git checkout bf1ed73d0d5ff46862ba69dd5eb2ffaeff6f19b6')\n efrotools.run(f'git checkout {PYTHON_VERSION_MAJOR}')\n\n # On mac we currently have to add the _scproxy module or urllib will\n # fail.\n txt = efrotools.readfile('patch/Python/Setup.embedded')\n if arch == 'mac':\n txt += ('\\n'\n '# ericf added - mac urllib needs this\\n'\n '_scproxy _scproxy.c '\n '-framework SystemConfiguration '\n '-framework CoreFoundation')\n\n # Turn off sqlite module. (scratch that; leaving it in.)\n # txt = efrotools.replace_one(txt, '_sqlite3 -I$(', '#_sqlite3 -I$(')\n # txt = txt.replace(' _sqlite/', '# _sqlite/')\n\n # Turn off xz compression module. (scratch that; leaving it in.)\n # txt = efrotools.replace_one(txt, '_lzma _', '#_lzma _')\n\n # Turn off bzip2 module.\n txt = efrotools.replace_one(txt, '_bz2 _b', '#_bz2 _b')\n\n # Turn off openssl module (only if not doing openssl).\n if not ENABLE_OPENSSL:\n txt = efrotools.replace_one(txt, '_hashlib _hashopenssl.c',\n '#_hashlib _hashopenssl.c')\n\n # Turn off various other stuff we don't use.\n for line in [\n '_codecs _codecsmodule.c',\n '_codecs_cn cjkcodecs/_codecs_cn.c',\n '_codecs_hk cjkcodecs/_codecs_hk.c',\n '_codecs_iso2022 cjkcodecs/',\n '_codecs_jp cjkcodecs/_codecs_jp.c',\n '_codecs_jp cjkcodecs/_codecs_jp.c',\n '_codecs_kr cjkcodecs/_codecs_kr.c',\n '_codecs_tw cjkcodecs/_codecs_tw.c',\n '_lsprof _lsprof.o rotatingtree.c',\n '_multibytecodec cjkcodecs/multibytecodec.c',\n '_multiprocessing _multiprocessing/multiprocessing.c',\n '_opcode _opcode.c',\n 'audioop audioop.c',\n 'grp grpmodule.c',\n 'mmap mmapmodule.c',\n 'parser parsermodule.c',\n 'pyexpat expat/xmlparse.c',\n ' expat/xmlrole.c ',\n ' expat/xmltok.c ',\n ' pyexpat.c ',\n ' -I$(srcdir)/Modules/expat ',\n ' -DHAVE_EXPAT_CONFIG_H -DUSE_PYEXPAT_CAPI'\n ' -DXML_DEV_URANDOM',\n 'resource resource.c',\n 'syslog syslogmodule.c',\n 'termios termios.c',\n '_ctypes_test _ctypes/_ctypes_test.c',\n '_testbuffer _testbuffer.c',\n '_testimportmultiple _testimportmultiple.c',\n '_crypt _cryptmodule.c', # not on android so disabling here too\n ]:\n txt = efrotools.replace_one(txt, line, '#' + line)\n\n if ENABLE_OPENSSL:\n\n # _md5 and _sha modules are normally only built if the\n # system does not have the OpenSSL libs containing an optimized\n # version.\n # Note: seems we still need sha3 or we get errors\n for line in [\n '_md5 md5module.c',\n '_sha1 sha1module.c',\n # '_sha3 _sha3/sha3module.c',\n '_sha256 sha256module.c',\n '_sha512 sha512module.c',\n ]:\n txt = efrotools.replace_one(txt, line, '#' + line)\n else:\n txt = efrotools.replace_one(txt, '_ssl _ssl.c', '#_ssl _ssl.c')\n efrotools.writefile('patch/Python/Setup.embedded', txt)\n\n txt = efrotools.readfile('Makefile')\n\n # Fix a bug where spaces in PATH cause errors (darn you vmware fusion!)\n txt = efrotools.replace_one(\n txt, '&& PATH=$(PROJECT_DIR)/$(PYTHON_DIR-macOS)/dist/bin:$(PATH) .',\n '&& PATH=\"$(PROJECT_DIR)/$(PYTHON_DIR-macOS)/dist/bin:$(PATH)\" .')\n\n # Remove makefile dependencies so we don't build the\n # libs we're not using.\n srctxt = '$$(PYTHON_DIR-$1)/dist/lib/libpython$(PYTHON_VER)m.a: '\n txt = efrotools.replace_one(\n txt, srctxt, '$$(PYTHON_DIR-$1)/dist/lib/libpython$(PYTHON_VER)m.a: ' +\n ('build/$2/Support/OpenSSL ' if ENABLE_OPENSSL else '') +\n 'build/$2/Support/XZ $$(PYTHON_DIR-$1)/Makefile\\n#' + srctxt)\n srctxt = ('dist/Python-$(PYTHON_VER)-$1-support.'\n '$(BUILD_NUMBER).tar.gz: ')\n txt = efrotools.replace_one(\n txt, srctxt,\n 'dist/Python-$(PYTHON_VER)-$1-support.$(BUILD_NUMBER).tar.gz:'\n ' $$(PYTHON_FRAMEWORK-$1)\\n#' + srctxt)\n\n # Turn doc strings on; looks like it only adds a few hundred k.\n txt = txt.replace('--without-doc-strings', '--with-doc-strings')\n\n # Set mac/ios version reqs\n # (see issue with utimensat and futimens).\n txt = efrotools.replace_one(txt, 'MACOSX_DEPLOYMENT_TARGET=10.8',\n 'MACOSX_DEPLOYMENT_TARGET=10.14')\n # And equivalent iOS (11+).\n txt = efrotools.replace_one(txt, 'CFLAGS-iOS=-mios-version-min=8.0',\n 'CFLAGS-iOS=-mios-version-min=12.0')\n # Ditto for tvOS.\n txt = efrotools.replace_one(txt, 'CFLAGS-tvOS=-mtvos-version-min=9.0',\n 'CFLAGS-tvOS=-mtvos-version-min=12.0')\n\n if debug:\n\n # Add debug build flag\n # (Currently expect to find 2 instances of this).\n dline = '--with-doc-strings --enable-ipv6 --without-ensurepip'\n splitlen = len(txt.split(dline))\n if splitlen != 3:\n raise Exception('unexpected configure lines')\n txt = txt.replace(dline, '--with-pydebug ' + dline)\n\n # Debug has a different name.\n # (Currently expect to replace 12 instances of this).\n dline = 'python$(PYTHON_VER)m'\n splitlen = len(txt.split(dline))\n if splitlen != 13:\n raise RuntimeError(f'Unexpected configure line count {splitlen}.')\n txt = txt.replace(dline, 'python$(PYTHON_VER)dm')\n\n efrotools.writefile('Makefile', txt)\n\n # Ok; let 'er rip.\n # (we run these in parallel so limit to 1 job a piece;\n # otherwise they inherit the -j12 or whatever from the top level)\n # (also this build seems to fail with multiple threads)\n efrotools.run('make -j1 ' + {\n 'mac': 'Python-macOS',\n 'ios': 'Python-iOS',\n 'tvos': 'Python-tvOS'\n }[arch])\n print('python build complete! (apple/' + arch + ')')","def compile_files(base, output, source, bind=True, amd=False):\n\n # Paths\n path = lambda *x: r.path(*[base] + list(x))\n tsc_path = path('node_modules', 'typescript', 'bin', 'tsc.js')\n output_folder = path(*output)\n source_folder = path(*source)\n\n # Compile each file. Sometimes --module seems to screw up the use\n # of --out, so safely check and fix if required.\n def collection(matches, run):\n for path in matches:\n output_module_name = os.path.basename(path)[:-3] + '.js'\n generated_file = os.path.join(source_folder, output_module_name)\n required_file = os.path.join(output_folder, output_module_name)\n run('mkdir', '-p', os.path.dirname(required_file))\n if amd:\n run('node', tsc_path, path, '--module', 'amd', '--out', required_file)\n else:\n run('node', tsc_path, path, '--out', required_file)\n if os.path.exists(generated_file): # wtf?\n run('mv', generated_file, required_file)\n\n # Build\n build = r.build()\n build.notice('Typescript multifile compile')\n build.chdir(source_folder)\n build.collect('.*\\.ts$', collection)\n\n # Target\n target = r.target(timeout=10)\n target.pattern('.*[^d]\\.ts$', dirname(source_folder), recurse=True)\n\n # Bind if required\n if bind:\n r.bind(target, build)\n\n # Run?\n if ruffx.BUILD:\n build.execute()\n\n return build","def test_clang_cxx(self):\n self.assertEqual(\n self.ndk.clang_cxx,\n f\"/opt/android/android-ndk/toolchains/llvm/prebuilt/{self.ndk.host_tag}/bin/clang++\",\n )","def compile(c_file: File) -> File:\n os.system(\"gcc -c {c_file}\".format(c_file=c_file.path))\n return File(c_file.path.replace('.c', '.o'))","def compile(self):\n print \"+ Nothing to be done ;)\"","def build(\n base_filename, src, bsp_c3, crt0_asm, march, opt_level, mmap,\n lang='c3', bin_format=None, elf_format=None, code_image='code'):\n list_filename = base_filename + '.html'\n\n with HtmlReportGenerator(open(list_filename, 'w')) as reporter:\n o1 = asm(crt0_asm, march)\n if lang == 'c3':\n srcs = [\n relpath('..', 'librt', 'io.c3'),\n bsp_c3,\n io.StringIO(src)]\n o2 = c3c(\n srcs, [], march, opt_level=opt_level,\n reporter=reporter, debug=True)\n objs = [o1, o2]\n elif lang == 'bf':\n o3 = bfcompile(src, march, reporter=reporter)\n o2 = c3c(\n [bsp_c3], [], march, reporter=reporter)\n objs = [o1, o2, o3]\n elif lang == 'c':\n o2 = c3c(\n [bsp_c3], [], march, reporter=reporter)\n coptions = COptions()\n include_path1 = relpath('..', 'librt', 'libc')\n coptions.add_include_path(include_path1)\n with open(relpath('..', 'librt', 'libc', 'lib.c'), 'r') as f:\n o3 = cc(\n f, march, coptions=coptions,\n reporter=reporter)\n o4 = cc(\n io.StringIO(src), march, coptions=coptions,\n reporter=reporter)\n objs = [o1, o2, o3, o4]\n else:\n raise NotImplementedError('language not implemented')\n obj = link(\n objs, layout=mmap,\n use_runtime=True, reporter=reporter, debug=True)\n\n # Save object:\n obj_file = base_filename + '.oj'\n with open(obj_file, 'w') as f:\n obj.save(f)\n\n if elf_format:\n elf_filename = base_filename + '.' + elf_format\n objcopy(obj, code_image, elf_format, elf_filename)\n\n # Export code image to some format:\n if bin_format:\n sample_filename = base_filename + '.' + bin_format\n objcopy(obj, code_image, bin_format, sample_filename)\n\n return obj","def cuda_compiler_flags():\n if ('CXX' in os.environ):\n exe = os.environ['CXX']\n else:\n exe = 'g++'\n gcc_flags = get_gcc_flags(exe)\n try:\n gcc_flags.remove('-std=c++11')\n except:\n pass\n gcc_flags += ['-DCUDA_DEBUG']\n gcc_flags_string = \" \".join(gcc_flags)\n nvcc_flags = ['-DCUDA_DEBUG'] # hardly adds overhead, recommended\n if CAD_DEBUG:\n nvcc_flags += ['-O0', '-g', '-G']\n else:\n if CAD_SAFE_CUDA_FLAGS:\n nvcc_flags += ['-O2']\n nvcc_flags += ['-use_fast_math']\n nvcc_flags += ['--generate-code', 'arch=compute_35,code=compute_35']\n else:\n nvcc_flags += ['-O3']\n nvcc_flags += ['-use_fast_math']\n # --- create cubin code\n nvcc_flags += ['--generate-code', 'arch=compute_35,code=sm_35']\n nvcc_flags += ['--generate-code', 'arch=compute_37,code=sm_37']\n if (CUDAVER[0] >= 6):\n nvcc_flags += ['--generate-code', 'arch=compute_50,code=sm_50']\n if (CUDAVER[0] >= 7):\n nvcc_flags += ['--generate-code', 'arch=compute_52,code=sm_52']\n nvcc_flags += ['--generate-code', 'arch=compute_53,code=sm_53']\n if (CUDAVER[0] >= 8):\n nvcc_flags += ['--generate-code', 'arch=compute_60,code=sm_60']\n nvcc_flags += ['--generate-code', 'arch=compute_61,code=sm_61']\n if (CUDAVER[0] >= 9):\n nvcc_flags += ['--generate-code', 'arch=compute_70,code=sm_70']\n if (CUDAVER[0] >= 10):\n nvcc_flags += ['--generate-code', 'arch=compute_75,code=sm_75']\n # --- generate PTX code for future compatibility\n if (CUDAVER[0] == 6):\n nvcc_flags += ['--generate-code', 'arch=compute_50,code=compute_50']\n if (CUDAVER[0] == 7):\n nvcc_flags += ['--generate-code', 'arch=compute_53,code=compute_53']\n if (CUDAVER[0] == 8):\n nvcc_flags += ['--generate-code', 'arch=compute_61,code=compute_61']\n if (CUDAVER[0] == 9):\n nvcc_flags += ['--generate-code', 'arch=compute_70,code=compute_70']\n if (CUDAVER[0] == 10):\n nvcc_flags += ['--generate-code', 'arch=compute_75,code=compute_75']\n nvcc_flags += ['--compiler-options=' + gcc_flags_string + ' -fPIC']\n print(\"NVCC flags: {}\".format(\" \".join(nvcc_flags)))\n return {'gcc': gcc_flags, 'nvcc': nvcc_flags}","def CustomCompileCheck(context, message, source, extension=\".cc\"):\n context.Message(message)\n\n env = context.env\n if env.GetOption(\"clean\") or env.GetOption(\"help\") or env.GetOption(\"no_exec\"):\n result = True\n else:\n result = context.TryCompile(source, extension)\n\n context.Result(result)\n\n return result","def generate(env):\n # NOTE: SCons requires the use of this name, which fails gpylint.\n\n # Set target platform bits\n env.SetBits('debug')\n\n env['TARGET_DEBUG'] = True\n\n env.Append(\n CPPDEFINES=['_DEBUG'] + env.get('CPPDEFINES_DEBUG', []),\n CCFLAGS=env.get('CCFLAGS_DEBUG', []),\n LINKFLAGS=env.get('LINKFLAGS_DEBUG', []),\n )","def main(argv):\n target = argv[1] if len(argv) >= 2 else 'all'\n if target not in ('all', 'flatbuffers', 'webp', 'clean'):\n sys.stderr.write('No rule to build target %s.\\n' % target)\n\n if target in ('all', 'flatbuffers'):\n try:\n generate_flatbuffer_binaries()\n except BuildError as error:\n handle_build_error(error)\n return 1\n if target in ('all', 'webp'):\n try:\n generate_webp_textures()\n except BuildError as error:\n handle_build_error(error)\n return 1\n if target == 'clean':\n try:\n clean()\n except OSError as error:\n sys.stderr.write('Error cleaning: %s' % str(error))\n return 1\n\n return 0","def compile_package(self):\n build_package = [\n self.mock,\n '--root=%s' % self.root,\n '--arch=%s' % self.arch,\n '--shell',\n '/build_package.sh',\n \n ]\n output, errors = self._run_command(build_package)","def try_compile_tmp(src_code, tmp_prefix='', flags=(), try_run=False):\r\n if not theano.config.cxx:\r\n return False\r\n\r\n flags = list(flags)\r\n compilation_ok = True\r\n run_ok = False\r\n try:\r\n fd, path = tempfile.mkstemp(suffix='.c', prefix=tmp_prefix)\r\n exe_path = path[:-2]\r\n try:\r\n # Python3 compatibility: try to cast Py3 strings as Py2 strings\r\n try:\r\n src_code = b(src_code)\r\n except Exception:\r\n pass\r\n os.write(fd, src_code)\r\n os.close(fd)\r\n fd = None\r\n p_ret = call_subprocess_Popen(\r\n ['g++', path, '-o', exe_path] + flags)\r\n if p_ret != 0:\r\n compilation_ok = False\r\n elif try_run:\r\n # Try to execute the program\r\n try:\r\n p_ret = call_subprocess_Popen([exe_path])\r\n run_ok = (p_ret == 0)\r\n finally:\r\n os.remove(exe_path)\r\n finally:\r\n try:\r\n if fd is not None:\r\n os.close(fd)\r\n finally:\r\n os.remove(path)\r\n\r\n except OSError, e:\r\n compilation_ok = False\r\n\r\n if not try_run:\r\n return compilation_ok\r\n else:\r\n return (compilation_ok, run_ok)"],"string":"[\n \"def pyo():\\n local('python -O -m compileall .')\",\n \"def pyo():\\n local('python -O -m compileall .')\",\n \"def build_program(source_files, image_type='bare-metal', opt_level='-O3', cflags=None):\\n assert isinstance(source_files, list)\\n\\n if not os.path.exists(OBJ_DIR):\\n os.makedirs(OBJ_DIR)\\n\\n compiler_args = [COMPILER_DIR + 'clang',\\n '-o', ELF_FILE,\\n '-w',\\n opt_level]\\n\\n if cflags:\\n compiler_args += cflags\\n\\n if image_type == 'raw':\\n compiler_args += ['-Wl,--script,../one-segment.ld,--oformat,binary']\\n elif image_type == 'user':\\n compiler_args += ['-Wl,--image-base=0x1000']\\n\\n compiler_args += source_files\\n\\n if any(name.endswith(('.c', '.cpp')) for name in source_files):\\n compiler_args += ['-I' + LIB_DIR + 'libc/include',\\n '-I' + LIB_DIR + 'libos',\\n LIB_DIR + 'libc/libc.a',\\n LIB_DIR + 'compiler-rt/compiler-rt.a']\\n if image_type == 'user':\\n compiler_args += [LIB_DIR + 'libos/crt0-kern.o',\\n LIB_DIR + 'libos/libos-kern.a']\\n else:\\n compiler_args += [LIB_DIR + 'libos/crt0-bare.o',\\n LIB_DIR + 'libos/libos-bare.a']\\n\\n try:\\n subprocess.check_output(compiler_args, stderr=subprocess.STDOUT)\\n if image_type == 'raw':\\n dump_hex(input_file=ELF_FILE, output_file=HEX_FILE)\\n return HEX_FILE\\n\\n if image_type == 'bare-metal':\\n subprocess.check_output([COMPILER_DIR + 'elf2hex', '-o', HEX_FILE, ELF_FILE],\\n stderr=subprocess.STDOUT)\\n return HEX_FILE\\n\\n return ELF_FILE\\n except subprocess.CalledProcessError as exc:\\n raise TestException('Compilation failed:\\\\n' + exc.output.decode())\",\n \"def build_from_c_and_cpp_files(extensions):\\n for extension in extensions:\\n sources = []\\n for sfile in extension.sources:\\n path, ext = os.path.splitext(sfile)\\n if ext in ('.pyx', '.py'):\\n if extension.language == 'c++':\\n ext = '.cpp'\\n else:\\n ext = '.c'\\n sfile = path + ext\\n sources.append(sfile)\\n extension.sources = sources\",\n \"def compile_c(self):\\n if(self.input == \\\"\\\"):\\n stderr = subprocess.run(\\n [\\\"gcc\\\", self.id+\\\".c\\\", \\\"-o\\\", self.id+\\\"_c\\\"], stderr=subprocess.PIPE).stderr.decode('utf-8')\\n if(len(stderr) == 0):\\n self.status = 1\\n stdout = subprocess.run(\\n [\\\"./\\\"+self.id+\\\"_c\\\"], stdout=subprocess.PIPE).stdout.decode('utf-8')\\n self.output = stdout\\n else:\\n self.status = 0\\n self.output = stderr\\n else:\\n pass\",\n \"def compile_cpp(self):\\n if(self.input == \\\"\\\"):\\n stderr = subprocess.run(\\n [\\\"g++\\\", self.id+\\\".cpp\\\", \\\"-o\\\", self.id+\\\"_cpp\\\"], stderr=subprocess.PIPE).stderr.decode('utf-8')\\n if(len(stderr) == 0):\\n self.status = 1\\n stdout = subprocess.run(\\n [\\\"./\\\"+self.id+\\\"_cpp\\\"], stdout=subprocess.PIPE).stdout.decode('utf-8')\\n self.output = stdout\\n else:\\n self.status = 0\\n self.output = stderr\\n else:\\n pass\",\n \"def cpp_compile(threads=2):\\n cmake_ret = subprocess.run([\\\"cmake\\\", \\\"../\\\"], encoding='utf-8', stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n output = cmake_ret.stdout\\n errors = cmake_ret.stderr\\n\\n output = \\\"\\\"\\n errors = \\\"\\\"\\n\\n make_ret = subprocess.run([\\\"make\\\", f\\\"-j{threads}\\\"], encoding='utf-8', stdout=subprocess.PIPE, stderr=subprocess.PIPE)\\n output = make_ret.stdout\\n errors = make_ret.stderr\\n return (make_ret.returncode == 0, errors if make_ret != 0 else None)\",\n \"def compile_and_link(self, src, dst):\\n cmd = [self.get_command(), src, \\\"-o\\\", dst] + self.__compiler_flags + self.__compiler_flags_extra + self.__definitions + self.__include_directories + self.get_linker_flags() + self.get_library_directory_list() + self.get_library_list()\\n (so, se) = run_command(cmd)\\n if 0 < len(se) and is_verbose():\\n print(se)\",\n \"def _compile_C_code(header, body, return_unloaded=False, verbose=False):\\n import importlib\\n import tempfile\\n import uuid\\n\\n import cffi\\n\\n module_name = \\\"module_\\\" + uuid.uuid4().hex\\n\\n if \\\"__uint128\\\" in header:\\n raise ValueError(\\\"_compile_C_code does not support bit-vector widths \\\"\\n \\\"larger than 64 bits (cffi does not support __uint128)\\\")\\n\\n ffibuilder = cffi.FFI()\\n ffibuilder.cdef(header)\\n ffibuilder.set_source(module_name, body)\\n\\n tmpdir = tempfile.TemporaryDirectory()\\n lib_path = ffibuilder.compile(tmpdir=tmpdir.name, verbose=verbose)\\n\\n if return_unloaded:\\n return lib_path, module_name, tmpdir\\n\\n # dynamic import\\n # https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly\\n spec = importlib.util.spec_from_file_location(module_name, lib_path)\\n pymod_parent = importlib.util.module_from_spec(spec)\\n # sys.modules[module_name] = module\\n spec.loader.exec_module(pymod_parent)\\n\\n pymod = pymod_parent\\n\\n return pymod, tmpdir\",\n \"def _pyCompile ( target, source, env ) :\\n if len(target) != 1 :\\n fail ( \\\"unexpected number of targets for pyCompile: \\\"+str(target) )\\n if len(source) != 1 :\\n fail ( \\\"unexpected number of sources for pyCompile: \\\"+str(source) )\\n\\n target = str(target[0])\\n source = str(source[0])\\n trace ( \\\"Executing pycompile `%s'\\\" % ( source ), \\\"pyCompile\\\", 3 )\\n\\n try :\\n import py_compile\\n py_compile.compile ( source, target, doraise = True )\\n except py_compile.PyCompileError, e :\\n print str(e)\\n return -1\",\n \"def compile_dir(path):\\r\\n to_compile = get_pyx_files(path)\\r\\n print(\\\"De:\\\",path)\\r\\n if to_compile:\\r\\n print(\\\"Se compilaran:\\\", list(map(os.path.basename,to_compile)))\\r\\n Cythonize.main( ['-a', '-i'] + to_compile )\\r\\n else:\\r\\n print(\\\"Nada para compilar\\\")\",\n \"def compile(self, **options):\\n pass\",\n \"def make_prog(prog_path: str, c_files: List[File]) -> File:\\n o_files = [\\n compile(c_file)\\n for c_file in c_files\\n ]\\n prog_file = link(prog_path, o_files)\\n return prog_file\",\n \"def CompiledBinary(\\n makefile=None,\\n compiler=\\\"gcc\\\",\\n sources=None,\\n binary_name=None,\\n is_32_bit=True,\\n executable_stack=True,\\n no_stack_protector=True,\\n aslr=False,\\n compiler_flags=None,\\n flag_file=None,\\n static_flag=None,\\n share_source=False,\\n remote=False,\\n):\\n\\n if compiler_flags is None:\\n compiler_flags = []\\n\\n if is_32_bit and \\\"-m32\\\" not in compiler_flags:\\n compiler_flags.append(\\\"-m32\\\")\\n if executable_stack and \\\"-zexecstack\\\" not in compiler_flags:\\n compiler_flags.append(\\\"-zexecstack\\\")\\n if no_stack_protector and \\\"-fno-stack-protector\\\" not in compiler_flags:\\n compiler_flags.append(\\\"-fno-stack-protector\\\")\\n if no_stack_protector and \\\"-D_FORTIFY_SOURCE=0\\\" not in compiler_flags:\\n compiler_flags.append(\\\"-D_FORTIFY_SOURCE=0\\\")\\n\\n if makefile is None and sources is None:\\n assert False, \\\"You must provide either a makefile or a sources list\\\"\\n\\n if sources is None:\\n assert (\\n binary_name is not None\\n ), \\\"You must provide the binary name if you use a makefile\\\"\\n\\n if flag_file is None:\\n flag_file = \\\"flag.txt\\\"\\n\\n base_classes = [Compiled]\\n if remote:\\n base_classes.append(Remote)\\n\\n class Problem(*base_classes):\\n files = copy([])\\n\\n remove_aslr = not aslr\\n\\n if share_source:\\n files = copy([File(source) for source in sources])\\n\\n if binary_name is not None:\\n program_name = binary_name\\n else:\\n program_name = os.path.splitext(sources[0])[0]\\n\\n def __init__(self):\\n self.makefile = makefile\\n self.compiler = compiler\\n self.compiler_sources = sources\\n self.compiler_flags = compiler_flags\\n\\n if not os.path.isfile(flag_file):\\n with open(flag_file, \\\"w\\\") as f:\\n f.write(\\\"{{flag}}\\\\n\\\")\\n\\n if static_flag is not None:\\n self.generate_flag = lambda random: static_flag\\n\\n self.files.append(ProtectedFile(flag_file))\\n\\n return Problem\",\n \"def run_cpp(self):\",\n \"def compile_helper(debug=0):\\n cmd = ['gcc', '-x', 'c', '-fPIC', '--shared', '-lpthread', '-lxclib',\\n '-o', '/tmp/libcygnet4k.so', '-']\\n if debug:\\n cmd[1:1] = ['-g', '-O0', '-DDEBUG=%d' % debug]\\n else:\\n cmd[1:1] = ['-O3']\\n\\n process = subprocess.Popen(cmd, stdin=subprocess.PIPE, bufsize=-1)\\n process.stdin.write(code)\\n process.stdin.close()\\n process.wait()\",\n \"def cross_compile(*args, **kwargs):\\n return compile(*args, **kwargs)\",\n \"def generate(env):\\n SCons.Tool.gcc.generate(env)\\n\\n detector = DetectCompiler()\\n if detector['icx'] is None:\\n raise SCons.Errors.InternalError(\\\"No oneapi compiler found\\\")\\n\\n env['INTEL_C_COMPILER_TOP'] = detector['root']\\n paths = {'INCLUDE': 'include',\\n 'LIB': 'libarch',\\n 'PATH': 'binarch',\\n 'LD_LIBRARY_PATH': 'libarch'}\\n for (key, value) in paths.items():\\n env.PrependENVPath(key, detector[value])\\n env.PrependENVPath(\\\"PATH\\\", detector[\\\"bin\\\"])\\n env.PrependENVPath(\\\"LIB\\\", detector[\\\"lib\\\"])\\n env.PrependENVPath(\\\"LD_LIBRARY_PATH\\\", detector[\\\"lib\\\"])\\n env['CC'] = 'icx'\\n env['CXX'] = 'icpx'\\n env['AR'] = 'ar'\\n env['LD'] = 'xild' # not used by default\",\n \"def link_pure(compilers, paths, output, promoted):\\n\\n\\t# assemble c++ link command\\n\\tcommand = []\\n\\tcommand.append(compilers['cxx'])\\n\\n\\tcommand.extend(['-L', paths['library']])\\n\\n\\tif output:\\n\\t\\tcommand.extend(['-o', output])\\n\\n\\tcommand.extend(promoted)\\n\\n\\tcommand.append('-lexampi')\\n\\tcommand.append('-pthread')\\n\\n\\t# execute compiler\\n\\treturn subprocess.call(command)\",\n \"def generate(env):\\n\\n gcc.generate(env)\\n\\n # Set up standard folder locations\\n env.SetDefault(SDK_TOOLS = env['TOOLS_ROOT'] + '/tools')\\n env.SetDefault(KCC_DIR = env['SDK_TOOLS'] + '/kcc/bin')\\n\\n env['KCC'] = _detect(env)\\n env['AS'] = '$KCC'\\n env['CC'] = '$KCC'\\n env['OBJSUFFIX'] = '.o'\\n env['BUILDERS']['AsmObject'] = _kccAsmBuilder\",\n \"def assemble(compilers, paths, output, promoted):\\n\\n\\t# assemble C compile command\\n\\tcommand = []\\n\\tcommand.append(compilers['cc'])\\n\\n\\tcommand.extend(['-I', paths['include']])\\n\\n\\tif output:\\n\\t\\tcommand.extend(['-o', output])\\n\\n\\tcommand.extend(promoted)\\n\\n\\t# execute compiler\\n\\treturn subprocess.call(command)\",\n \"def compile(self, app, pad, outputpad, lang='c++', *args):\\n frame2 = args[0]\\n Display.show_outputpad(frame2, outputpad)\\n if lang == 'c++':\\n global FLAG\\n FLAG = 0\\n\\n \\\"\\\"\\\"\\n Windows system\\n \\\"\\\"\\\"\\n\\n if platform.system() == 'Windows':\\n # remove the old exe and replace it with current one\\n os.remove('a.exe')\\n # Save_As file automatically before compiling\\n x = cmd_file.Save(app, pad)\\n\\n if x == -1:\\n p = subprocess.Popen(\\n [\\n \\\"C:\\\\\\\\Program Files (x86)\\\\\\\\MinGW\\\\\\\\bin\\\\\\\\g++.exe\\\",\\n '-std=c++14',\\n 'untitled.cpp'],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n else:\\n p = subprocess.Popen(\\n [\\n \\\"C:\\\\\\\\Program Files (x86)\\\\\\\\MinGW\\\\\\\\bin\\\\\\\\g++.exe\\\",\\n '-std=c++14',\\n File.path],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n status = p.communicate()[1]\\n outputpad.config(state=GUI.NORMAL)\\n outputpad.delete('1.0', GUI.END)\\n if len(status) == 0:\\n outputpad.insert(GUI.END, 'compiled successfully \\\\n')\\n else:\\n outputpad.insert(GUI.END, status + '\\\\n')\\n p.terminate()\\n return -1\\n p.terminate()\\n outputpad.config(state=GUI.DISABLED)\\n \\\"\\\"\\\"\\n Linux\\n \\\"\\\"\\\"\\n\\n if platform.system() == 'Linux':\\n # No need to terminate process in linux\\n x = cmd_file.Save(app, pad)\\n\\n if x == -1:\\n p = subprocess.Popen(\\n [\\n \\\"g++\\\",\\n '-std=c++11',\\n 'untitled.cpp'],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n else:\\n p = subprocess.Popen(\\n [\\n \\\"g++\\\",\\n '-std=c++11',\\n File.path],\\n stdin=subprocess.PIPE,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.PIPE)\\n status = p.communicate()[1]\\n outputpad.config(state=GUI.NORMAL)\\n outputpad.delete('1.0', GUI.END)\\n if len(status) == 0:\\n outputpad.insert(GUI.END, 'compiled successfully \\\\n')\\n else:\\n outputpad.insert(GUI.END, status + '\\\\n')\\n # p.terminate()\\n return -1\\n # p.terminate()\\n outputpad.config(state=GUI.DISABLED)\\n\\n if lang == 'py':\\n outputpad.config(state=GUI.NORMAL)\\n outputpad.delete('1.0', 'end')\\n outputpad.insert(GUI.INSERT, 'Python programs are interpreted. Press run instead')\",\n \"def _get_c_flags(\\n target,\\n cc,\\n cflags,\\n debug,\\n srcfiles=None,\\n sharedobject=False,\\n osname=None,\\n verbose=False,\\n):\\n flags = []\\n\\n # define c flags\\n if cc is not None:\\n # remove .exe extension of necessary\\n cc = _get_base_app_name(cc)\\n\\n # remove target .exe extension, if necessary\\n target = _get_base_app_name(target)\\n\\n # get lower case OS string\\n if osname is None:\\n osname = _get_osname()\\n\\n # get - or / to prepend for compiler switches\\n prepend = _get_prepend(cc, osname)\\n\\n # generate c flags\\n if cc in [\\\"gcc\\\", \\\"g++\\\"]:\\n if sharedobject:\\n if osname != \\\"win32\\\":\\n flags.append(\\\"fPIC\\\")\\n else:\\n if osname == \\\"win32\\\":\\n flags.append(\\\"static\\\")\\n if \\\"fPIC\\\" in flags:\\n flags.remove(\\\"fPIC\\\")\\n if debug:\\n flags += [\\\"g\\\"]\\n if _check_gnu_switch_available(\\n \\\"-Wall\\\", compiler=\\\"gcc\\\", verbose=verbose\\n ):\\n flags.append(\\\"Wall\\\")\\n else:\\n pass\\n elif cc in [\\\"clang\\\", \\\"clang++\\\"]:\\n if sharedobject:\\n msg = \\\"shared library not implement fo clang\\\"\\n raise NotImplementedError(msg)\\n if debug:\\n flags += [\\\"g\\\"]\\n if _check_gnu_switch_available(\\n \\\"-Wall\\\", compiler=\\\"clang\\\", verbose=verbose\\n ):\\n flags.append(\\\"Wall\\\")\\n else:\\n pass\\n elif cc in [\\\"icc\\\", \\\"icpc\\\", \\\"mpiicc\\\", \\\"mpiicpc\\\", \\\"icl\\\", \\\"cl\\\"]:\\n if osname == \\\"win32\\\":\\n if cc in [\\\"icl\\\", \\\"cl\\\"]:\\n flags += [\\\"nologo\\\"]\\n if debug:\\n flags.append(\\\"/debug:full\\\")\\n else:\\n if sharedobject:\\n flags.append(\\\"fpic\\\")\\n else:\\n if \\\"fpic\\\" in flags:\\n flags.remove(\\\"fpic\\\")\\n\\n if debug:\\n flags += [\\\"debug full\\\"]\\n elif cc in [\\\"cl\\\"]:\\n if osname == \\\"win32\\\":\\n if debug:\\n flags.append(\\\"Zi\\\")\\n\\n # Add -D-UF flag for C code if ISO_C_BINDING is not used in Fortran\\n # code that is linked to C/C++ code. Only needed if there are\\n # any fortran files. -D_UF defines UNIX naming conventions for\\n # mixed language compilation.\\n if srcfiles is not None:\\n ffiles = _get_fortran_files(srcfiles)\\n cfiles = _get_c_files(srcfiles)\\n if ffiles is not None:\\n iso_c_check = True\\n if osname == \\\"win32\\\":\\n if cc in [\\\"icl\\\", \\\"cl\\\"]:\\n iso_c_check = False\\n if iso_c_check:\\n use_iso_c = _get_iso_c(ffiles)\\n if not use_iso_c and cfiles is not None:\\n flags.append(\\\"D_UF\\\")\\n\\n # process passed c flags - check for flags with a space between\\n # the flag and a setting\\n for idx, flag in enumerate(cflags[1:]):\\n if flag[0] not in (\\\"/\\\", \\\"-\\\"):\\n cflags[idx] += \\\" {}\\\".format(flag)\\n cflags[idx + 1] = \\\"\\\"\\n\\n # add passed c flags - assume that flags have - or / as the\\n # first character. c flags starting with O are excluded\\n for flag in cflags:\\n if len(flag) < 1:\\n continue\\n if flag[1] != \\\"O\\\":\\n if flag[1:] not in flags:\\n flags.append(flag[1:])\\n\\n # add target specific c/c++ switches\\n tlist = _set_cflags(target, cc=cc, argv=False, osname=osname)\\n if tlist is not None:\\n for flag in tlist:\\n if flag[1] != \\\"O\\\":\\n if flag[1:] not in flags:\\n flags.append(flag[1:])\\n\\n # add prepend to compiler flags\\n for idx, flag in enumerate(flags):\\n flags[idx] = prepend + flag\\n\\n return flags\",\n \"def compile_java(self):\\n if(self.input == \\\"\\\"):\\n stderr = subprocess.run(\\n [\\\"javac\\\", self.id+\\\".java\\\"], stderr=subprocess.PIPE).stderr.decode('utf-8')\\n if(len(stderr) == 0):\\n self.status = 1\\n stdout = subprocess.run(\\n [\\\"java\\\"+self.id], stdout=subprocess.PIPE).stdout.decode('utf-8')\\n self.output = stdout\\n else:\\n self.status = 0\\n self.output = stderr\\n else:\\n pass\",\n \"def build_cffi():\\r\\n print_banner(\\\"Building CFFI Module\\\")\\r\\n ffi = cffi.FFI()\\r\\n\\r\\n this_dir = pathlib.Path().resolve()\\r\\n h_file_name = this_dir / \\\"cmult.h\\\"\\r\\n with open(h_file_name) as h_file:\\r\\n # cffi does not like our preprocessor directives, so we remove them\\r\\n lns = h_file.read().splitlines()\\r\\n flt = filter(lambda ln: not re.match(r\\\" *#\\\", ln), lns)\\r\\n flt = map(lambda ln: ln.replace(\\\"EXPORT_SYMBOL \\\", \\\"\\\"), flt)\\r\\n ffi.cdef(str(\\\"\\\\n\\\").join(flt))\\r\\n\\r\\n ffi.set_source(\\r\\n \\\"cffi_example\\\",\\r\\n # Since we are calling a fully built library directly no custom source\\r\\n # is necessary. We need to include the .h files, though, because behind\\r\\n # the scenes cffi generates a .c file which contains a Python-friendly\\r\\n # wrapper around each of the functions.\\r\\n '#include \\\"cmult.h\\\"',\\r\\n # The important thing is to include the pre-built lib in the list of\\r\\n # libraries we are linking against:\\r\\n libraries=[\\\"cmult\\\"],\\r\\n library_dirs=[this_dir.as_posix()],\\r\\n extra_link_args=[\\\"-Wl,-rpath,.\\\"],\\r\\n )\\r\\n\\r\\n ffi.compile()\\r\\n print(\\\"* Complete\\\")\",\n \"def build_extension(self, ext):\\n if sys.platform == \\\"win32\\\":\\n _clr_compiler = \\\"C:\\\\\\\\Windows\\\\\\\\Microsoft.NET\\\\\\\\Framework\\\\\\\\v4.0.30319\\\\\\\\csc.exe\\\"\\n else:\\n _clr_compiler = \\\"mcs\\\"\\n cmd = [ \\n _clr_compiler,\\n \\\"/target:library\\\",\\n \\\"clrmagic.cs\\\"\\n ]\\n check_call(\\\" \\\".join(cmd), shell=True)\",\n \"def build(self):\\n env = ConfigureEnvironment(self.deps_cpp_info, self.settings)\\n\\n set_path_command = \\\"\\\"\\n # Download nasm as build tool. This should go to source()\\n if self.options.SSE == True:\\n if self.settings.os == \\\"Linux\\\":\\n # TODO: We should build nasm from source then.\\n self.options.SSE = False # Or is removing here better? I'm not familiar with python..\\n else:\\n nasm_version = \\\"2.12.02\\\"\\n nasm_os_url_id = \\\"\\\" #nasm url identifier\\n if self.settings.os == \\\"Windows\\\":\\n if self.settings.arch == \\\"x86\\\":\\n nasm_os_url_id = \\\"win32\\\"\\n else:\\n nasm_os_url_id = \\\"win64\\\" \\n elif self.settings.os == \\\"Macos\\\":\\n nasm_os_url_id = \\\"macosx\\\"\\n nasm_folder_name = \\\"nasm-%s-%s\\\" % (nasm_version, nasm_os_url_id)\\n nasm_zip_name = \\\"%s.zip\\\" % nasm_folder_name\\n download(\\\"http://www.nasm.us/pub/nasm/releasebuilds/%s/%s/%s\\\" % (nasm_version, nasm_os_url_id, nasm_zip_name), nasm_zip_name)\\n self.output.warn(\\\"Downloading nasm: http://www.nasm.us/pub/nasm/releasebuilds/%s/%s/%s\\\" % (nasm_version, nasm_os_url_id, nasm_zip_name))\\n unzip(nasm_zip_name)\\n os.unlink(nasm_zip_name)\\n nasm_path = os.path.join(os.getcwd(), nasm_folder_name)\\n\\n #env.environ[\\\"PATH\\\"] += os.pathsep + nasm_path #its probably as easy as this, but i cant append to the path self.run operates in.\\n if self.settings.os == \\\"Windows\\\":\\n set_path_command = \\\"set \\\\\\\"PATH=%s\\\\\\\" &&\\\" % os.environ[\\\"PATH\\\"]\\n else:\\n set_path_command = \\\"PATH=\\\\\\\"%s\\\\\\\" &&\\\" % os.environ[\\\"PATH\\\"]\\n\\n if self.settings.os == \\\"Linux\\\" or self.settings.os == \\\"Macos\\\":\\n if self.options.fPIC:\\n env_line = env.command_line.replace('CFLAGS=\\\"', 'CFLAGS=\\\"-fPIC ')\\n else:\\n env_line = env.command_line\\n self.run(\\\"cd %s && autoreconf -fiv\\\" % self.ZIP_FOLDER_NAME)\\n config_options = \\\"\\\"\\n if self.settings.arch == \\\"x86\\\":\\n if self.settings.os == \\\"Linux\\\":\\n config_options = \\\"--host i686-pc-linux-gnu CFLAGS='-O3 -m32' LDFLAGS=-m32\\\"\\n else:\\n config_options = \\\"--host i686-apple-darwin CFLAGS='-O3 -m32' LDFLAGS=-m32\\\"\\n\\n if self.settings.os == \\\"Macos\\\":\\n old_str = '-install_name \\\\$rpath/\\\\$soname'\\n new_str = '-install_name \\\\$soname'\\n replace_in_file(\\\"./%s/configure\\\" % self.ZIP_FOLDER_NAME, old_str, new_str)\\n\\n self.run(\\\"cd %s && %s ./configure %s\\\" % (self.ZIP_FOLDER_NAME, env_line, config_options))\\n self.run(\\\"cd %s && %s make\\\" % (self.ZIP_FOLDER_NAME, env_line))\\n else: # We should (for simplicity) always use cmake shouldnt we?\\n conan_magic_lines = '''project(libjpeg-turbo)\\n cmake_minimum_required(VERSION 3.0)\\n include(../conanbuildinfo.cmake)\\n CONAN_BASIC_SETUP()\\n '''\\n replace_in_file(\\\"%s/CMakeLists.txt\\\" % self.ZIP_FOLDER_NAME, \\\"cmake_minimum_required(VERSION 2.8.8)\\\", conan_magic_lines)\\n replace_in_file(\\\"%s/CMakeLists.txt\\\" % self.ZIP_FOLDER_NAME, \\\"project(libjpeg-turbo C)\\\", \\\"\\\")\\n \\n cmake = CMake(self.settings)\\n builddir = os.path.join(self.ZIP_FOLDER_NAME, \\\"_build\\\")\\n\\n if os.path.exists(builddir):\\n shutil.rmtree(builddir) # We need to remove this folder first for windows\\n os.makedirs(builddir)\\n\\n cmake_options = []\\n if self.options.shared == True:\\n cmake_options += [\\\"-DENABLE_STATIC=0\\\"]\\n else:\\n cmake_options = [\\\"-DENABLE_SHARED=0\\\"]\\n cmake_options += [\\\"-DWITH_SIMD=%s\\\" % \\\"1\\\" if self.options.SSE else \\\"0\\\"]\\n\\n # why this comment: \\\"Don't change runtime, conan will take care of\\\"? conan_basic_setup() runs before this cmake option replaces MT with MD again\\n cmake_options += [\\\"-DWITH_CRT_DLL=%s\\\" % \\\"1\\\" if self.settings.compiler.runtime == \\\"MD\\\" or self.settings.compiler.runtime == \\\"MDd\\\" else \\\"0\\\"]\\n\\n self.run('%s cd %s && cmake .. %s %s' % (set_path_command, builddir, cmake.command_line, \\\" \\\".join(cmake_options)))\\n self.run(\\\"%s cd %s && cmake --build . %s\\\" % (set_path_command, builddir, cmake.build_config))\",\n \"def _compile(self, source: str, filename: str) -> CodeType:\\n return compile(source, filename, \\\"exec\\\") # type: ignore\",\n \"def test_make_benchmark_from_command_line_mixed_source_and_object_files(\\n env: LlvmEnv, retcode: int\\n):\\n with temporary_working_directory():\\n with open(\\\"a.c\\\", \\\"w\\\") as f:\\n f.write(\\n \\\"\\\"\\\"\\n#include \\\"b.h\\\"\\n\\nint A() {\\n return B();\\n}\\n\\nint main() {\\n return A();\\n}\\n\\\"\\\"\\\"\\n )\\n\\n with open(\\\"b.c\\\", \\\"w\\\") as f:\\n f.write(f\\\"int B() {{ return {retcode}; }}\\\")\\n\\n with open(\\\"b.h\\\", \\\"w\\\") as f:\\n f.write(\\\"int B();\\\")\\n\\n # Compile b.c to object file:\\n subprocess.check_call([str(llvm_paths.clang_path()), \\\"b.c\\\", \\\"-c\\\"], timeout=60)\\n assert (Path(\\\"b.o\\\")).is_file()\\n\\n bm = env.make_benchmark_from_command_line([\\\"gcc\\\", \\\"a.c\\\", \\\"b.o\\\", \\\"-o\\\", \\\"foo\\\"])\\n env.reset(benchmark=bm)\\n\\n bm.compile(env)\\n assert Path(\\\"foo\\\").is_file()\\n\\n p = subprocess.Popen([\\\"./foo\\\"])\\n p.communicate(timeout=60)\\n assert p.returncode == retcode\",\n \"def build_step(self):\\n run_cmd('./compile.sh', log_all=True, simple=True, log_ok=True)\",\n \"def compile_cutils():\\r\\n\\r\\n types = ['npy_' + t for t in ['int8', 'int16', 'int32', 'int64', 'int128',\\r\\n 'int256', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',\\r\\n 'float16', 'float32', 'float64', 'float80', 'float96', 'float128',\\r\\n 'float256']]\\r\\n\\r\\n complex_types = ['npy_' + t for t in ['complex32', 'complex64',\\r\\n 'complex128', 'complex160', 'complex192', 'complex512']]\\r\\n\\r\\n inplace_map_template = \\\"\\\"\\\"\\r\\n #if defined(%(typen)s)\\r\\n static void %(type)s_inplace_add(PyArrayMapIterObject *mit, PyArrayIterObject *it)\\r\\n {\\r\\n int index = mit->size;\\r\\n while (index--) {\\r\\n %(op)s\\r\\n\\r\\n PyArray_MapIterNext(mit);\\r\\n PyArray_ITER_NEXT(it);\\r\\n }\\r\\n }\\r\\n #endif\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n floatadd = \\\"((%(type)s*)mit->dataptr)[0] = ((%(type)s*)mit->dataptr)[0] + ((%(type)s*)it->dataptr)[0];\\\"\\r\\n complexadd = \\\"\\\"\\\"\\r\\n ((%(type)s*)mit->dataptr)[0].real = ((%(type)s*)mit->dataptr)[0].real + ((%(type)s*)it->dataptr)[0].real;\\r\\n ((%(type)s*)mit->dataptr)[0].imag = ((%(type)s*)mit->dataptr)[0].imag + ((%(type)s*)it->dataptr)[0].imag;\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n fns = ''.join([inplace_map_template % {'type': t, 'typen': t.upper(),\\r\\n 'op': floatadd % {'type': t}}\\r\\n for t in types] +\\r\\n [inplace_map_template % {'type': t, 'typen': t.upper(),\\r\\n 'op': complexadd % {'type': t}}\\r\\n for t in complex_types])\\r\\n\\r\\n fn_array = (\\\"static inplace_map_binop addition_funcs[] = {\\\" +\\r\\n ''.join([\\\"\\\"\\\"\\r\\n #if defined(%(typen)s)\\r\\n %(type)s_inplace_add,\\r\\n #endif\\r\\n \\\"\\\"\\\" % {'type': t, 'typen': t.upper()}\\r\\n for t in types + complex_types]) +\\r\\n \\\"\\\"\\\"NULL};\\r\\n \\\"\\\"\\\")\\r\\n\\r\\n type_number_array = (\\\"static int type_numbers[] = {\\\" +\\r\\n ''.join([\\\"\\\"\\\"\\r\\n #if defined(%(typen)s)\\r\\n %(typen)s,\\r\\n #endif\\r\\n \\\"\\\"\\\" % {'type': t, 'typen': t.upper()}\\r\\n for t in types + complex_types]) +\\r\\n \\\"-1000};\\\")\\r\\n\\r\\n code = (\\\"\\\"\\\"\\r\\n #include <Python.h>\\r\\n #include \\\"numpy/arrayobject.h\\\"\\r\\n\\r\\n extern \\\"C\\\"{\\r\\n static PyObject *\\r\\n run_cthunk(PyObject *self, PyObject *args)\\r\\n {\\r\\n PyObject *py_cthunk = NULL;\\r\\n if(!PyArg_ParseTuple(args,\\\"O\\\",&py_cthunk))\\r\\n return NULL;\\r\\n\\r\\n if (!PyCObject_Check(py_cthunk)) {\\r\\n PyErr_SetString(PyExc_ValueError,\\r\\n \\\"Argument to run_cthunk must be a PyCObject.\\\");\\r\\n return NULL;\\r\\n }\\r\\n void * ptr_addr = PyCObject_AsVoidPtr(py_cthunk);\\r\\n int (*fn)(void*) = (int (*)(void*))(ptr_addr);\\r\\n void* it = PyCObject_GetDesc(py_cthunk);\\r\\n int failure = fn(it);\\r\\n\\r\\n return Py_BuildValue(\\\"i\\\", failure);\\r\\n }\\r\\n\\r\\n #if NPY_API_VERSION >= 0x00000008\\r\\n typedef void (*inplace_map_binop)(PyArrayMapIterObject *, PyArrayIterObject *);\\r\\n \\\"\\\"\\\" + fns + fn_array + type_number_array +\\r\\n\\r\\n\\\"\\\"\\\"\\r\\nstatic int\\r\\nmap_increment(PyArrayMapIterObject *mit, PyObject *op, inplace_map_binop add_inplace)\\r\\n{\\r\\n PyArrayObject *arr = NULL;\\r\\n PyArrayIterObject *it;\\r\\n PyArray_Descr *descr;\\r\\n if (mit->ait == NULL) {\\r\\n return -1;\\r\\n }\\r\\n descr = PyArray_DESCR(mit->ait->ao);\\r\\n Py_INCREF(descr);\\r\\n arr = (PyArrayObject *)PyArray_FromAny(op, descr,\\r\\n 0, 0, NPY_ARRAY_FORCECAST, NULL);\\r\\n if (arr == NULL) {\\r\\n return -1;\\r\\n }\\r\\n if ((mit->subspace != NULL) && (mit->consec)) {\\r\\n PyArray_MapIterSwapAxes(mit, (PyArrayObject **)&arr, 0);\\r\\n if (arr == NULL) {\\r\\n return -1;\\r\\n }\\r\\n }\\r\\n it = (PyArrayIterObject*)\\r\\n PyArray_BroadcastToShape((PyObject*)arr, mit->dimensions, mit->nd);\\r\\n if (it == NULL) {\\r\\n Py_DECREF(arr);\\r\\n return -1;\\r\\n }\\r\\n\\r\\n (*add_inplace)(mit, it);\\r\\n\\r\\n Py_DECREF(arr);\\r\\n Py_DECREF(it);\\r\\n return 0;\\r\\n}\\r\\n\\r\\n\\r\\nstatic PyObject *\\r\\ninplace_increment(PyObject *dummy, PyObject *args)\\r\\n{\\r\\n PyObject *arg_a = NULL, *index=NULL, *inc=NULL;\\r\\n PyArrayObject *a;\\r\\n inplace_map_binop add_inplace = NULL;\\r\\n int type_number = -1;\\r\\n int i =0;\\r\\n PyArrayMapIterObject * mit;\\r\\n\\r\\n if (!PyArg_ParseTuple(args, \\\"OOO\\\", &arg_a, &index,\\r\\n &inc)) {\\r\\n return NULL;\\r\\n }\\r\\n if (!PyArray_Check(arg_a)) {\\r\\n PyErr_SetString(PyExc_ValueError, \\\"needs an ndarray as first argument\\\");\\r\\n return NULL;\\r\\n }\\r\\n\\r\\n a = (PyArrayObject *) arg_a;\\r\\n\\r\\n if (PyArray_FailUnlessWriteable(a, \\\"input/output array\\\") < 0) {\\r\\n return NULL;\\r\\n }\\r\\n\\r\\n if (PyArray_NDIM(a) == 0) {\\r\\n PyErr_SetString(PyExc_IndexError, \\\"0-d arrays can't be indexed.\\\");\\r\\n return NULL;\\r\\n }\\r\\n type_number = PyArray_TYPE(a);\\r\\n\\r\\n\\r\\n\\r\\n while (type_numbers[i] >= 0 && addition_funcs[i] != NULL){\\r\\n if (type_number == type_numbers[i]) {\\r\\n add_inplace = addition_funcs[i];\\r\\n break;\\r\\n }\\r\\n i++ ;\\r\\n }\\r\\n\\r\\n if (add_inplace == NULL) {\\r\\n PyErr_SetString(PyExc_TypeError, \\\"unsupported type for a\\\");\\r\\n return NULL;\\r\\n }\\r\\n mit = (PyArrayMapIterObject *) PyArray_MapIterArray(a, index);\\r\\n if (mit == NULL) {\\r\\n goto fail;\\r\\n }\\r\\n if (map_increment(mit, inc, add_inplace) != 0) {\\r\\n goto fail;\\r\\n }\\r\\n\\r\\n Py_DECREF(mit);\\r\\n\\r\\n Py_INCREF(Py_None);\\r\\n return Py_None;\\r\\n\\r\\nfail:\\r\\n Py_XDECREF(mit);\\r\\n\\r\\n return NULL;\\r\\n}\\r\\n #endif\\r\\n\\r\\n\\r\\n static PyMethodDef CutilsExtMethods[] = {\\r\\n {\\\"run_cthunk\\\", run_cthunk, METH_VARARGS|METH_KEYWORDS,\\r\\n \\\"Run a theano cthunk.\\\"},\\r\\n #if NPY_API_VERSION >= 0x00000008\\r\\n {\\\"inplace_increment\\\", inplace_increment,\\r\\n METH_VARARGS,\\r\\n \\\"increments a numpy array inplace at the passed indexes.\\\"},\\r\\n #endif\\r\\n {NULL, NULL, 0, NULL} /* Sentinel */\\r\\n };\\\"\\\"\\\")\\r\\n\\r\\n if PY3:\\r\\n # This is not the most efficient code, but it is written this way to\\r\\n # highlight the changes needed to make 2.x code compile under python 3.\\r\\n code = code.replace(\\\"<Python.h>\\\", '\\\"numpy/npy_3kcompat.h\\\"', 1)\\r\\n code = code.replace(\\\"PyCObject\\\", \\\"NpyCapsule\\\")\\r\\n code += \\\"\\\"\\\"\\r\\n static struct PyModuleDef moduledef = {\\r\\n PyModuleDef_HEAD_INIT,\\r\\n \\\"cutils_ext\\\",\\r\\n NULL,\\r\\n -1,\\r\\n CutilsExtMethods,\\r\\n };\\r\\n\\r\\n PyMODINIT_FUNC\\r\\n PyInit_cutils_ext(void) {\\r\\n import_array();\\r\\n return PyModule_Create(&moduledef);\\r\\n }\\r\\n }\\r\\n \\\"\\\"\\\"\\r\\n else:\\r\\n code += \\\"\\\"\\\"\\r\\n PyMODINIT_FUNC\\r\\n initcutils_ext(void)\\r\\n {\\r\\n import_array();\\r\\n (void) Py_InitModule(\\\"cutils_ext\\\", CutilsExtMethods);\\r\\n }\\r\\n } //extern C\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n loc = os.path.join(config.compiledir, 'cutils_ext')\\r\\n if not os.path.exists(loc):\\r\\n os.mkdir(loc)\\r\\n\\r\\n args = cmodule.GCC_compiler.compile_args()\\r\\n cmodule.GCC_compiler.compile_str('cutils_ext', code, location=loc,\\r\\n preargs=args)\",\n \"def build_cmult(path=\\\"C:\\\\\\\\Program Files (x86)\\\\\\\\Microsoft Visual Studio\\\\\\\\2019\\\\\\\\Professional\\\\\\\\VC\\\\\\\\Auxiliary\\\\\\\\Build\\\\\\\\\\\"):\\r\\n # Moving this type hint into signature causes an error (???)\\r\\n c = invoke.Context()\\r\\n\\r\\n if on_win:\\r\\n if not path:\\r\\n print(\\\"Path is missing\\\")\\r\\n else:\\r\\n # Using c.cd didn't work with paths that have spaces :/\\r\\n path = f'\\\"{path}vcvars32.bat\\\" x64' # Enter the VS venv\\r\\n path += f'&& cd \\\"{os.getcwd()}\\\"' # Change to current dir\\r\\n path += \\\"&& cl /LD cmult.c\\\" # Compile\\r\\n # Uncomment line below, to suppress stdout\\r\\n # path = path.replace(\\\"&&\\\", \\\" >nul &&\\\") + \\\" >nul\\\"\\r\\n c.run(path)\\r\\n else:\\r\\n print_banner(\\\"Building C Library\\\")\\r\\n cmd = \\\"gcc -c -Wall -Werror -fpic cmult.c -I /usr/include/python3.7\\\"\\r\\n invoke.run(cmd)\\r\\n invoke.run(\\\"gcc -shared -o libcmult.so cmult.o\\\")\\r\\n print(\\\"* Complete\\\")\",\n \"def build_extensions(self):\\n c = self.compiler.compiler_type\\n CF = [] ; LF=[]\\n if \\\"CFLAGS\\\" in os.environ:\\n CF = os.environ.get(\\\"CFLAGS\\\").split(\\\" \\\")\\n if \\\"LDFLAGS\\\" in os.environ:\\n LF = os.environ.get(\\\"LDFLAGS\\\").split(\\\" \\\")\\n for e in self.extensions:\\n if c in copt:\\n e.extra_compile_args = copt[ c ] + CF\\n e.extra_link_args = lopt[ c ] + LF\\n print(\\\"Customised compiler\\\",c,e.extra_compile_args,\\n e.extra_link_args)\\n build_ext.build_ext.build_extensions(self)\",\n \"def compile(proj_dir, make_flags=None):\\n\\n if not make_flags:\\n make_flags = []\\n os.chdir(proj_dir)\\n print(\\\"Running 'make %s'\\\" % \\\" \\\".join(make_flags))\\n # print(sh.make(make_flags))\\n shell([\\\"make\\\"] + make_flags)\\n os.chdir(HERE)\\n\\n # existing hex file indicates a succeeded compile\\n proj_name = os.path.basename(proj_dir)\\n assert os.path.exists(os.path.join(proj_dir, \\\"applet\\\", proj_name + \\\".hex\\\"))\",\n \"def compile_args():\\r\\n flags = [flag for flag in config.nvcc.flags.split(' ') if flag]\\r\\n if config.nvcc.fastmath:\\r\\n flags.append('-use_fast_math')\\r\\n cuda_ndarray_cuh_hash = hash_from_file(\\r\\n os.path.join(os.path.split(theano.sandbox.cuda.__file__)[0],\\r\\n 'cuda_ndarray.cuh'))\\r\\n flags.append('-DCUDA_NDARRAY_CUH=' + cuda_ndarray_cuh_hash)\\r\\n\\r\\n # numpy 1.7 deprecated the following macros but they didn't\\r\\n # exist in the past\\r\\n numpy_ver = [int(n) for n in numpy.__version__.split('.')[:2]]\\r\\n if bool(numpy_ver < [1, 7]):\\r\\n flags.append(\\\"-D NPY_ARRAY_ENSURECOPY=NPY_ENSURECOPY\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_ALIGNED=NPY_ALIGNED\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_WRITEABLE=NPY_WRITEABLE\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_UPDATE_ALL=NPY_UPDATE_ALL\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_C_CONTIGUOUS=NPY_C_CONTIGUOUS\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_F_CONTIGUOUS=NPY_F_CONTIGUOUS\\\")\\r\\n\\r\\n # If the user didn't specify architecture flags add them\\r\\n if not any(['-arch=sm_' in f for f in flags]):\\r\\n dev = theano.sandbox.gpuarray.init_dev.device\\r\\n if dev is None:\\r\\n raise Exception, \\\"Trying to compile GPU code without a context\\\"\\r\\n if dev.startswith(\\\"opencl\\\"):\\r\\n raise Exception, \\\"Trying to call nvcc with an OpenCL context\\\"\\r\\n assert dev.startswith('cuda')\\r\\n if dev == 'cuda':\\r\\n n = theano.sandbox.cuda.use.device_number\\r\\n else:\\r\\n n = int(dev[4:])\\r\\n p = theano.sandbox.cuda.device_properties(n)\\r\\n flags.append('-arch=sm_' + str(p['major']) + str(p['minor']))\\r\\n\\r\\n return flags\",\n \"def c_compile(tmpdir, ext, hpy_devel, hpy_abi, compiler_verbose=0, debug=None):\\n saved_environ = os.environ.copy()\\n try:\\n outputfilename = _build(tmpdir, ext, hpy_devel, hpy_abi, compiler_verbose, debug)\\n outputfilename = os.path.abspath(outputfilename)\\n finally:\\n # workaround for a distutils bugs where some env vars can\\n # become longer and longer every time it is used\\n for key, value in saved_environ.items():\\n if os.environ.get(key) != value:\\n os.environ[key] = value\\n return outputfilename\",\n \"def make_c_header(self):\\n res = \\\\\\n\\\"\\\"\\\"PyThreadState* ___madz_LANG_python_thread_state; //Holds Thread State for this interpreter\\nPyObject *___madz_LANG_python_wrapper_module; //Hold Pointer to the _madz.py file representing this plugin\\ntypedef struct{{\\n{function_pointers}\\n}}___madz_LANG_python_TYPE_;\\n___madz_LANG_python_TYPE_ ___madz_LANG_python_OUTPUT;\\nvoid ___madz_init_imports();\\n{fn_dec}\\n\\n\\\"\\\"\\\"\\n c_gen = c_wrapgen.CGenerator([],\\\"\\\", self.description)\\n #TODO function_pointers, all same except\\n fragments ={\\\"fn_dec\\\" : \\\"\\\", \\\"function_pointers\\\" : \\\"\\\"}\\n fn = \\\"\\\"\\\"{rettype}{fnname}({args});\\\\n\\\"\\\"\\\"\\n pointer = \\\"\\\"\\\" {prettype} (*{nodename})({args});\\\\n\\\"\\\"\\\"\\n for node in self.description.definitions():\\n if isinstance(node.type.get_type(), pdl.TypeFunction):\\n frg = {\\n \\\"prettype\\\": c_gen.gen_type_string(\\\"\\\", node.type.return_type),\\n \\\"rettype\\\": c_gen.gen_type_string(\\\"\\\", node.type.return_type),\\n \\\"fnname\\\": \\\"___madz_LANG_python_FN_\\\" + node.name,\\n \\\"nodename\\\": node.name,\\n \\\"args\\\": \\\",\\\".join(map(\\n lambda a: c_gen.gen_type_string(a.name, a.type),\\n node.type.args)),\\n\\n }\\n fragments[\\\"fn_dec\\\"] += fn.format(**frg)\\n fragments[\\\"function_pointers\\\"] += pointer.format(**frg)\\n if fragments[\\\"function_pointers\\\"] == \\\"\\\":\\n fragments[\\\"function_pointers\\\"] = \\\"uint8_t _madz_empty;\\\"\\n return res.format(**fragments)\",\n \"def compile_code():\\n pyc_cmd = \\\"python3 ../course/common/compiler.py \\\"\\n\\n with open('log.out', 'w+', encoding=\\\"utf-8\\\") as f:\\n subprocess.call(shlex.split(pyc_cmd + './student/'), universal_newlines=True, stderr=f)\\n f.seek(0)\\n out_student = f.read()\\n\\n if out_student != \\\"\\\":\\n rawhtml = rst.get_codeblock(\\\"\\\", out_student)\\n feedback.set_global_result('failed')\\n feedback.set_global_feedback(_(\\\"Your program does not compile: \\\\n \\\") + rawhtml + \\\"\\\\n\\\")\\n sys.exit(0)\",\n \"def drive_compile(args):\\n tvmc_model = frontends.load_model(args.FILE, args.model_format, args.input_shapes)\\n\\n dump_code = [x.strip() for x in args.dump_code.split(\\\",\\\")] if args.dump_code else None\\n\\n compile_model(\\n tvmc_model,\\n args.target,\\n opt_level=args.opt_level,\\n executor=reconstruct_registry_entity(args, Executor),\\n runtime=reconstruct_registry_entity(args, Runtime),\\n tuning_records=args.tuning_records,\\n package_path=args.output,\\n cross=args.cross_compiler,\\n cross_options=args.cross_compiler_options,\\n output_format=args.output_format,\\n dump_code=dump_code,\\n target_host=None,\\n desired_layout=args.desired_layout,\\n disabled_pass=args.disabled_pass,\\n pass_context_configs=args.pass_config,\\n additional_target_options=reconstruct_target_args(args),\\n )\\n\\n return 0\",\n \"def generate(env):\\n c_file, cxx_file = SCons.Tool.createCFileBuilders(env)\\n\\n # C\\n c_file.add_action(\\\".l\\\", LexAction)\\n c_file.add_emitter(\\\".l\\\", lexEmitter)\\n\\n c_file.add_action(\\\".lex\\\", LexAction)\\n c_file.add_emitter(\\\".lex\\\", lexEmitter)\\n\\n # Objective-C\\n cxx_file.add_action(\\\".lm\\\", LexAction)\\n cxx_file.add_emitter(\\\".lm\\\", lexEmitter)\\n\\n # C++\\n cxx_file.add_action(\\\".ll\\\", LexAction)\\n cxx_file.add_emitter(\\\".ll\\\", lexEmitter)\\n\\n env[\\\"LEX\\\"] = env.Detect(\\\"flex\\\") or \\\"lex\\\"\\n env[\\\"LEXFLAGS\\\"] = SCons.Util.CLVar(\\\"\\\")\\n env[\\\"LEXCOM\\\"] = \\\"$LEX $LEXFLAGS -t $SOURCES > $TARGET\\\"\",\n \"def _compile(self, filename, source):\\n \\n if source and source[-1] != '\\\\n':\\n source = source + '\\\\n'\\n code = __builtin__.compile(source, filename.cStr(), 'exec')\\n\\n # try to cache the compiled code\\n pycFilename = Filename(filename)\\n pycFilename.setExtension(pycExtension)\\n try:\\n f = open(pycFilename, 'wb')\\n except IOError:\\n pass\\n else:\\n f.write('\\\\0\\\\0\\\\0\\\\0')\\n f.write(struct.pack('<I', self.timestamp))\\n f.write(marshal.dumps(code))\\n f.flush()\\n f.seek(0, 0)\\n f.write(imp.get_magic())\\n f.close()\\n\\n return code\",\n \"def generate(env) -> None:\\n c_file, cxx_file = SCons.Tool.createCFileBuilders(env)\\n\\n # C\\n c_file.add_action(\\\".l\\\", LexAction)\\n c_file.add_emitter(\\\".l\\\", lexEmitter)\\n\\n c_file.add_action(\\\".lex\\\", LexAction)\\n c_file.add_emitter(\\\".lex\\\", lexEmitter)\\n\\n # Objective-C\\n cxx_file.add_action(\\\".lm\\\", LexAction)\\n cxx_file.add_emitter(\\\".lm\\\", lexEmitter)\\n\\n # C++\\n cxx_file.add_action(\\\".ll\\\", LexAction)\\n cxx_file.add_emitter(\\\".ll\\\", lexEmitter)\\n\\n if sys.platform == 'win32':\\n # ignore the return, all we need is for the path to be added\\n _ = get_lex_path(env, append_paths=True)\\n\\n env.SetDefault(\\n LEX=env.Detect(BINS),\\n LEXFLAGS=CLVar(\\\"\\\"),\\n LEX_HEADER_FILE=\\\"\\\",\\n LEX_TABLES_FILE=\\\"\\\",\\n )\\n\\n if sys.platform == 'win32':\\n env.SetDefault(LEXUNISTD=CLVar(\\\"\\\"))\\n env[\\\"LEXCOM\\\"] = \\\"$LEX $LEXUNISTD $LEXFLAGS $_LEX_HEADER $_LEX_TABLES -t $SOURCES > $TARGET\\\"\\n else:\\n env[\\\"LEXCOM\\\"] = \\\"$LEX $LEXFLAGS $_LEX_HEADER $_LEX_TABLES -t $SOURCES > $TARGET\\\"\\n\\n env['_LEX_HEADER'] = '${LEX_HEADER_FILE and \\\"--header-file=\\\" + str(LEX_HEADER_FILE)}'\\n env['_LEX_TABLES'] = '${LEX_TABLES_FILE and \\\"--tables-file=\\\" + str(LEX_TABLES_FILE)}'\",\n \"def compile(*files, exe_name=None, cc=CC, **cflags):\\n\\n if not files:\\n raise RuntimeError(_(\\\"compile requires at least one file\\\"))\\n\\n if exe_name is None and files[0].endswith(\\\".c\\\"):\\n exe_name = Path(files[0]).stem\\n\\n files = \\\" \\\".join(files)\\n\\n flags = CFLAGS.copy()\\n flags.update(cflags)\\n flags = \\\" \\\".join((f\\\"-{flag}\\\" + (f\\\"={value}\\\" if value is not True else \\\"\\\")).replace(\\\"_\\\", \\\"-\\\")\\n for flag, value in flags.items() if value)\\n\\n out_flag = f\\\" -o {exe_name} \\\" if exe_name is not None else \\\" \\\"\\n\\n process = run(f\\\"{cc} {files}{out_flag}{flags}\\\")\\n\\n # Strip out ANSI codes\\n stdout = re.sub(r\\\"\\\\x1B\\\\[[0-?]*[ -/]*[@-~]\\\", \\\"\\\", process.stdout())\\n\\n if process.exitcode != 0:\\n for line in stdout.splitlines():\\n log(line)\\n raise Failure(\\\"code failed to compile\\\")\",\n \"def _make_source(name, init, body):\\n code = \\\"\\\"\\\"\\n #include <Python.h>\\n\\n %(body)s\\n\\n PyMODINIT_FUNC\\n PyInit_%(name)s(void) {\\n %(init)s\\n }\\n \\\"\\\"\\\" % dict(\\n name=name, init=init, body=body,\\n )\\n return code\",\n \"def _compile(self, context, source, double=False, prelude=\\\"\\\", **kwds):\\n\\t\\tkernel_src = Template(source).render(**kwds)\\n\\t\\tsrc = _header.render(cuda=False, double=double, kernels=kernel_src, prelude=prelude)\\n\\t\\tself._program = cl.Program(context, src).build(options='-cl-mad-enable')\",\n \"def main():\\n for key in UNSAFE_FLAGS:\\n if key in os.environ:\\n del os.environ[key]\\n\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--fcompiler', choices=['pgi', 'intel', 'gfortran'],\\n help='Fortran compiler to use')\\n parser.add_argument('--usecuda', help='whether to also compile CUDA implementation',\\n action='store_true')\\n parser.add_argument('--debug', help='use debug configuration when compiling fortran code',\\n action='store_true')\\n\\n cmd_args = parser.parse_args()\\n args = ['python', 'setup.py', 'build_ext', '--fcompiler=' + FCOMPILER_MAP[cmd_args.fcompiler]]\\n if cmd_args.debug:\\n args += ['--debug']\\n if cmd_args.usecuda:\\n args += ['--usecuda']\\n args += ['build', 'bdist_wheel']\\n\\n proc = subprocess.Popen(['rm', '-rf', 'dist', 'build'])\\n proc.wait()\\n\\n proc = subprocess.Popen(args)\\n proc.wait()\\n if proc.returncode != 0:\\n print('ERROR! build process failed.')\\n exit(1)\\n\\n wheels = glob.glob('./dist/*.whl')\\n latest_wheel = max(wheels, key=os.path.getctime)\\n\\n proc = subprocess.Popen(['pip', 'install', latest_wheel, '--upgrade'])\\n proc.wait()\",\n \"def partial_build(src, lang, bsp_c3, opt_level, march, reporter):\\n if lang == 'c3':\\n srcs = [\\n relpath('..', 'librt', 'io.c3'),\\n bsp_c3,\\n io.StringIO(src)]\\n o2 = c3c(\\n srcs, [], march, opt_level=opt_level,\\n reporter=reporter, debug=True)\\n objs = [o2]\\n elif lang == 'bf':\\n o3 = bfcompile(src, march, reporter=reporter)\\n o2 = c3c(\\n [bsp_c3], [], march, reporter=reporter)\\n objs = [o2, o3]\\n elif lang == 'c':\\n o2 = c3c(\\n [bsp_c3], [], march, reporter=reporter)\\n coptions = COptions()\\n include_path1 = relpath('..', 'librt', 'libc')\\n coptions.add_include_path(include_path1)\\n with open(relpath('..', 'librt', 'libc', 'lib.c'), 'r') as f:\\n o3 = cc(\\n f, march, coptions=coptions, debug=True,\\n reporter=reporter)\\n o4 = cc(\\n io.StringIO(src), march, coptions=coptions, debug=True,\\n reporter=reporter)\\n objs = [o2, o3, o4]\\n else:\\n raise NotImplementedError('language not implemented')\\n obj = link(\\n objs, partial_link=True,\\n use_runtime=True, reporter=reporter, debug=True)\\n return obj\",\n \"def link(compilers, paths, output, promoted):\\n\\n\\tif not any(source.endswith('.c') for source in promoted):\\n\\t\\t# no C files passed -> C++ linking\\n\\t\\treturn link_pure(compilers, paths, output, promoted)\\n\\n\\t# C files passed -> intermediate compiling -> C++ linking\\n\\tsources = [source for source in promoted if source.endswith('.c')]\\n\\tseparate = [sep for sep in promoted if not sep.endswith('.c')]\\n\\n\\tobject_files = []\\n\\n\\tfor source in sources:\\n\\t\\t# produce intermediate object file\\n\\t\\tobject_filename = 'exampi_' + random_string() + '.o'\\n\\n\\t\\terror_code = assemble(compilers, paths, object_filename, separate + ['-c', source])\\n\\n\\t\\t# check for intermediate product failure\\n\\t\\tif error_code != 0:\\n\\t\\t\\treturn error_code\\n\\n\\t\\tobject_files.append(object_filename)\\n\\n\\t# link all outputs\\n\\terror_code = link_pure(compilers, paths, output, separate + object_files)\\n\\n\\t# delete intermediate objects\\n\\tfor object_file in object_files:\\n\\t\\tos.remove(object_file)\\n\\n\\treturn error_code\",\n \"def compile(base, output, source, bind=True, skip=False):\\n\\n # Paths\\n path = lambda *x: r.path(*[base] + list(x))\\n tsc_path = path('node_modules', 'typescript', 'bin', 'tsc.js')\\n output_path = path(*output)\\n source_path = path(*source)\\n source_folder = path(*source[:-1])\\n\\n # Build\\n build = r.build()\\n build.notice('Typescript compile')\\n build.chdir(source_folder)\\n build.run('node', tsc_path, source_path, '--declaration', '--out', output_path)\\n\\n # Target\\n target = r.target(timeout=10)\\n target.pattern('.*\\\\.ts$', dirname(source_path), recurse=True)\\n\\n # Bind if required\\n if bind:\\n r.bind(target, build)\\n\\n # Run?\\n if ruffx.BUILD and not skip:\\n build.execute()\\n\\n return build\",\n \"def compile_args():\\r\\n flags = [flag for flag in config.nvcc.flags.split(' ') if flag]\\r\\n if config.nvcc.fastmath:\\r\\n flags.append('-use_fast_math')\\r\\n cuda_ndarray_cuh_hash = hash_from_file(\\r\\n os.path.join(os.path.split(__file__)[0], 'cuda_ndarray.cuh'))\\r\\n flags.append('-DCUDA_NDARRAY_CUH=' + cuda_ndarray_cuh_hash)\\r\\n\\r\\n # numpy 1.7 deprecated the following macro but the didn't\\r\\n # existed in the past\\r\\n numpy_ver = [int(n) for n in numpy.__version__.split('.')[:2]]\\r\\n if bool(numpy_ver < [1, 7]):\\r\\n flags.append(\\\"-D NPY_ARRAY_ENSURECOPY=NPY_ENSURECOPY\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_ALIGNED=NPY_ALIGNED\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_WRITEABLE=NPY_WRITEABLE\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_UPDATE_ALL=NPY_UPDATE_ALL\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_C_CONTIGUOUS=NPY_C_CONTIGUOUS\\\")\\r\\n flags.append(\\\"-D NPY_ARRAY_F_CONTIGUOUS=NPY_F_CONTIGUOUS\\\")\\r\\n\\r\\n # If the user didn't specify architecture flags add them\\r\\n if not any(['-arch=sm_' in f for f in flags]):\\r\\n # We compile cuda_ndarray.cu during import.\\r\\n # We should not add device properties at that time.\\r\\n # As the device is not selected yet!\\r\\n # TODO: re-compile cuda_ndarray when we bind to a GPU?\\r\\n import theano.sandbox.cuda\\r\\n if hasattr(theano.sandbox, 'cuda'):\\r\\n n = theano.sandbox.cuda.use.device_number\\r\\n if n is None:\\r\\n _logger.warn(\\r\\n \\\"We try to get compilation arguments for CUDA\\\"\\r\\n \\\" code, but the GPU device is not initialized.\\\"\\r\\n \\\" This is probably caused by an Op that work on\\\"\\r\\n \\\" the GPU that don't inherit from GpuOp.\\\"\\r\\n \\\" We Initialize the GPU now.\\\")\\r\\n theano.sandbox.cuda.use(\\r\\n \\\"gpu\\\",\\r\\n force=True,\\r\\n default_to_move_computation_to_gpu=False,\\r\\n move_shared_float32_to_gpu=False,\\r\\n enable_cuda=False)\\r\\n n = theano.sandbox.cuda.use.device_number\\r\\n p = theano.sandbox.cuda.device_properties(n)\\r\\n flags.append('-arch=sm_' + str(p['major']) +\\r\\n str(p['minor']))\\r\\n\\r\\n return flags\",\n \"def fiddle_with_flags():\\n flags['c++'] += '-arch x86_64 -bundle'\\n flags['c'] += '-arch x86_64'\",\n \"def __init__(self, path_prefix=\\\"\\\"):\\n self.gcc_path = path_prefix + \\\"gcc\\\"\",\n \"def run(compiler: str, language: str, prelude: str, coda: str, snippet: str):\\n with tempfile.TemporaryDirectory() as tmp:\\n\\n src = Path(tmp) / f\\\"main.{language}\\\"\\n src.write_text(f\\\"{prelude}{snippet}{coda}\\\")\\n\\n dst = Path(tmp) / \\\"a.out\\\"\\n\\n std = \\\"-std=c++20\\\" if language == \\\"c++\\\" else \\\"-std=c11\\\"\\n subprocess.check_call(\\n [compiler, std, \\\"-Wall\\\", \\\"-Wextra\\\", \\\"-x\\\", language, \\\"-o\\\", dst, src]\\n )\\n\\n subprocess.check_call([dst])\",\n \"def generate_vala_compile(self, target: build.BuildTarget) -> \\\\\\n T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File], T.List[str]]:\\n (vala_src, vapi_src, other_src) = self.split_vala_sources(target)\\n extra_dep_files = []\\n if not vala_src:\\n raise InvalidArguments(f'Vala library {target.name!r} has no Vala or Genie source files.')\\n\\n valac = target.compilers['vala']\\n c_out_dir = self.get_target_private_dir(target)\\n # C files generated by valac\\n vala_c_src: T.List[str] = []\\n # Files generated by valac\\n valac_outputs: T.List = []\\n # All sources that are passed to valac on the commandline\\n all_files = list(vapi_src)\\n # Passed as --basedir\\n srcbasedir = os.path.join(self.build_to_src, target.get_subdir())\\n for (vala_file, gensrc) in vala_src.items():\\n all_files.append(vala_file)\\n # Figure out where the Vala compiler will write the compiled C file\\n #\\n # If the Vala file is in a subdir of the build dir (in our case\\n # because it was generated/built by something else), and is also\\n # a subdir of --basedir (because the builddir is in the source\\n # tree, and the target subdir is the source root), the subdir\\n # components from the source root till the private builddir will be\\n # duplicated inside the private builddir. Otherwise, just the\\n # basename will be used.\\n #\\n # If the Vala file is outside the build directory, the paths from\\n # the --basedir till the subdir will be duplicated inside the\\n # private builddir.\\n if isinstance(gensrc, (build.CustomTarget, build.GeneratedList)) or gensrc.is_built:\\n vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'\\n # Check if the vala file is in a subdir of --basedir\\n abs_srcbasedir = os.path.join(self.environment.get_source_dir(), target.get_subdir())\\n abs_vala_file = os.path.join(self.environment.get_build_dir(), vala_file)\\n if PurePath(os.path.commonpath((abs_srcbasedir, abs_vala_file))) == PurePath(abs_srcbasedir):\\n vala_c_subdir = PurePath(abs_vala_file).parent.relative_to(abs_srcbasedir)\\n vala_c_file = os.path.join(str(vala_c_subdir), vala_c_file)\\n else:\\n path_to_target = os.path.join(self.build_to_src, target.get_subdir())\\n if vala_file.startswith(path_to_target):\\n vala_c_file = os.path.splitext(os.path.relpath(vala_file, path_to_target))[0] + '.c'\\n else:\\n vala_c_file = os.path.splitext(os.path.basename(vala_file))[0] + '.c'\\n # All this will be placed inside the c_out_dir\\n vala_c_file = os.path.join(c_out_dir, vala_c_file)\\n vala_c_src.append(vala_c_file)\\n valac_outputs.append(vala_c_file)\\n\\n args = self.generate_basic_compiler_args(target, valac)\\n args += valac.get_colorout_args(target.get_option(OptionKey('b_colorout')))\\n # Tell Valac to output everything in our private directory. Sadly this\\n # means it will also preserve the directory components of Vala sources\\n # found inside the build tree (generated sources).\\n args += ['--directory', c_out_dir]\\n args += ['--basedir', srcbasedir]\\n if target.is_linkable_target():\\n # Library name\\n args += ['--library', target.name]\\n # Outputted header\\n hname = os.path.join(self.get_target_dir(target), target.vala_header)\\n args += ['--header', hname]\\n if target.is_unity:\\n # Without this the declarations will get duplicated in the .c\\n # files and cause a build failure when all of them are\\n # #include-d in one .c file.\\n # https://github.com/mesonbuild/meson/issues/1969\\n args += ['--use-header']\\n valac_outputs.append(hname)\\n # Outputted vapi file\\n vapiname = os.path.join(self.get_target_dir(target), target.vala_vapi)\\n # Force valac to write the vapi and gir files in the target build dir.\\n # Without this, it will write it inside c_out_dir\\n args += ['--vapi', os.path.join('..', target.vala_vapi)]\\n valac_outputs.append(vapiname)\\n target.outputs += [target.vala_header, target.vala_vapi]\\n target.install_tag += ['devel', 'devel']\\n # Install header and vapi to default locations if user requests this\\n if len(target.install_dir) > 1 and target.install_dir[1] is True:\\n target.install_dir[1] = self.environment.get_includedir()\\n if len(target.install_dir) > 2 and target.install_dir[2] is True:\\n target.install_dir[2] = os.path.join(self.environment.get_datadir(), 'vala', 'vapi')\\n # Generate GIR if requested\\n if isinstance(target.vala_gir, str):\\n girname = os.path.join(self.get_target_dir(target), target.vala_gir)\\n args += ['--gir', os.path.join('..', target.vala_gir)]\\n valac_outputs.append(girname)\\n target.outputs.append(target.vala_gir)\\n target.install_tag.append('devel')\\n # Install GIR to default location if requested by user\\n if len(target.install_dir) > 3 and target.install_dir[3] is True:\\n target.install_dir[3] = os.path.join(self.environment.get_datadir(), 'gir-1.0')\\n # Detect gresources and add --gresources arguments for each\\n for gensrc in other_src[1].values():\\n if isinstance(gensrc, modules.GResourceTarget):\\n gres_xml, = self.get_custom_target_sources(gensrc)\\n args += ['--gresources=' + gres_xml]\\n extra_args = []\\n\\n for a in target.extra_args.get('vala', []):\\n if isinstance(a, File):\\n relname = a.rel_to_builddir(self.build_to_src)\\n extra_dep_files.append(relname)\\n extra_args.append(relname)\\n else:\\n extra_args.append(a)\\n dependency_vapis = self.determine_dep_vapis(target)\\n extra_dep_files += dependency_vapis\\n args += extra_args\\n element = NinjaBuildElement(self.all_outputs, valac_outputs,\\n self.compiler_to_rule_name(valac),\\n all_files + dependency_vapis)\\n element.add_item('ARGS', args)\\n element.add_dep(extra_dep_files)\\n self.add_build(element)\\n self.create_target_source_introspection(target, valac, args, all_files, [])\\n return other_src[0], other_src[1], vala_c_src\",\n \"def runall(sources='sources'):\\n init()\\n upload_sources(sources)\\n compile()\\n run()\",\n \"def compile_malloc():\\n src = path_from_root('src', 'dlmalloc.c')\\n includes = '-I' + path_from_root('src', 'include')\\n command = [shared.CLANG, '-c', '-g', '-emit-llvm'] + shared.COMPILER_OPTS + ['-o-', includes, src]\\n with temp_files.get('.bc') as out: ret = subprocess.call(command, stdout=out)\\n if ret != 0: raise RuntimeError('Could not compile dlmalloc.')\\n return out.name\",\n \"def generate_binary_minimal(source_file, compiler, assembler, linker, objcopy, und_symbols, elfling, libraries,\\n output_file):\\n if source_file:\\n compiler.compile_asm(source_file, output_file + \\\".S\\\")\\n segment_ehdr = AssemblerSegment(assembler_ehdr)\\n if osarch_is_32_bit():\\n segment_phdr_dynamic = AssemblerSegment(assembler_phdr32_dynamic)\\n segment_phdr_interp = AssemblerSegment(assembler_phdr32_interp)\\n elif osarch_is_64_bit():\\n segment_phdr_dynamic = AssemblerSegment(assembler_phdr64_dynamic)\\n segment_phdr_interp = AssemblerSegment(assembler_phdr64_interp)\\n else:\\n raise_unknown_address_size()\\n segment_dynamic = AssemblerSegment(assembler_dynamic)\\n segment_hash = AssemblerSegment(assembler_hash)\\n segment_interp = AssemblerSegment(assembler_interp)\\n segment_strtab = AssemblerSegment(assembler_strtab)\\n segment_symtab = AssemblerSegment(assembler_symtab)\\n # There may be symbols necessary for addition.\\n if is_listing(und_symbols):\\n segment_symtab.add_symbol_empty()\\n for ii in und_symbols:\\n segment_symtab.add_symbol_und(ii)\\n for ii in reversed(und_symbols):\\n segment_strtab.add_strtab(ii)\\n segment_dynamic.add_dt_symtab(\\\"symtab\\\")\\n segment_dynamic.add_dt_hash(\\\"hash\\\")\\n segment_hash.add_hash(und_symbols)\\n else:\\n segment_dynamic.add_dt_symtab(0)\\n # Add libraries.\\n for ii in reversed(libraries):\\n library_name = linker.get_library_name(ii)\\n segment_dynamic.add_dt_needed(library_name)\\n segment_strtab.add_strtab(library_name)\\n # Assembler file generation is more complex when elfling is enabled.\\n if elfling:\\n elfling.write_c_source(output_file + \\\".elfling.cpp\\\")\\n compiler.compile_asm(output_file + \\\".elfling.cpp\\\", output_file + \\\".elfling.S\\\")\\n asm = AssemblerFile(output_file + \\\".elfling.S\\\")\\n additional_asm = AssemblerFile(output_file + \\\".S\\\")\\n # Entry point is used as compression start information.\\n elfling_align = int(PlatformVar(\\\"memory_page\\\"))\\n if elfling.has_data():\\n alignment_section = AssemblerSectionAlignment(elfling_align, ELFLING_PADDING, ELFLING_OUTPUT, \\\"end\\\")\\n set_program_start(\\\"_start\\\")\\n else:\\n alignment_section = AssemblerSectionAlignment(elfling_align, ELFLING_PADDING, ELFLING_OUTPUT)\\n set_program_start(ELFLING_OUTPUT)\\n asm.add_sections(alignment_section)\\n asm.incorporate(additional_asm, \\\"_incorporated\\\", ELFLING_UNCOMPRESSED)\\n else:\\n asm = AssemblerFile(output_file + \\\".S\\\")\\n additional_asm = None\\n alignment_section = None\\n # May be necessary to have two PT_LOAD headers as opposed to one.\\n bss_section = asm.generate_fake_bss(assembler, und_symbols, elfling)\\n if 0 < bss_section.get_alignment():\\n replace_platform_variable(\\\"phdr_count\\\", 4)\\n if osarch_is_32_bit():\\n segment_phdr_load_double = AssemblerSegment(assembler_phdr32_load_double)\\n segment_phdr_load_bss = AssemblerSegment(assembler_phdr32_load_bss)\\n elif osarch_is_64_bit():\\n segment_phdr_load_double = AssemblerSegment(assembler_phdr64_load_double)\\n segment_phdr_load_bss = AssemblerSegment(assembler_phdr64_load_bss)\\n else:\\n raise_unknown_address_size()\\n load_segments = [segment_phdr_load_double, segment_phdr_load_bss]\\n else:\\n if osarch_is_32_bit():\\n segment_phdr_load_single = AssemblerSegment(assembler_phdr32_load_single)\\n elif osarch_is_64_bit():\\n segment_phdr_load_single = AssemblerSegment(assembler_phdr64_load_single)\\n else:\\n raise_unknown_address_size()\\n load_segments = [segment_phdr_load_single]\\n # Collapse headers.\\n segments_head = [segment_ehdr, segment_phdr_interp]\\n segments_tail = [segment_phdr_dynamic]\\n if is_listing(und_symbols):\\n segments_tail += [segment_hash]\\n segments_tail += [segment_dynamic]\\n if is_listing(und_symbols):\\n segments_tail += [segment_symtab]\\n segments_tail += [segment_interp, segment_strtab]\\n segments = merge_segments(segments_head) + load_segments + merge_segments(segments_tail)\\n # Calculate total size of headers.\\n header_sizes = 0\\n fd = open(output_file + \\\".combined.S\\\", \\\"w\\\")\\n for ii in segments:\\n ii.write(fd, assembler)\\n header_sizes += ii.size()\\n if is_verbose():\\n print(\\\"Size of headers: %i bytes\\\" % (header_sizes))\\n # Create content of earlier sections and write source when done.\\n if alignment_section:\\n alignment_section.create_content(assembler)\\n if elfling and elfling.has_data():\\n bss_section.create_content(assembler)\\n else:\\n bss_section.create_content(assembler, \\\"end\\\")\\n asm.write(fd, assembler)\\n fd.close()\\n if is_verbose():\\n print(\\\"Wrote assembler source '%s'.\\\" % (output_file + \\\".combined.S\\\"))\\n assembler.assemble(output_file + \\\".combined.S\\\", output_file + \\\".o\\\")\\n linker.generate_linker_script(output_file + \\\".ld\\\", True)\\n linker.set_linker_script(output_file + \\\".ld\\\")\\n linker.link_binary(output_file + \\\".o\\\", output_file + \\\".bin\\\")\\n run_command([objcopy, \\\"--output-target=binary\\\", output_file + \\\".bin\\\", output_file + \\\".unprocessed\\\"])\\n readelf_truncate(output_file + \\\".unprocessed\\\", output_file + \\\".stripped\\\")\",\n \"def compile(self, args, classpath, sources, classes_output_dir, analysis_file):\\r\\n raise NotImplementedError()\",\n \"def generate_cpp():\\n cpp_file = AUTOGEN_WARNING\\n cpp_file += \\\"// Implements basic nuclear data functions.\\\\n\\\"\\n cpp_file += \\\"#ifndef PYNE_IS_AMALGAMATED\\\\n\\\"\\n cpp_file += '#include \\\"atomic_data.h\\\"\\\\n'\\n cpp_file += '#include \\\"nucname.h\\\"\\\\n'\\n cpp_file += \\\"#endif\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\"void pyne::_load_atomic_mass_map_memory() { \\\\n\\\"\\n cpp_file += \\\" // header version of atomic weight table data \\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!atomic_mass_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_atomic_mass_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" //see if the data table is already loaded\\\\n\\\"\\n cpp_file += \\\" if(!natural_abund_map.empty()) {\\\\n\\\"\\n cpp_file += \\\" return;\\\\n\\\"\\n cpp_file += \\\" } else { \\\\n\\\"\\n cpp_file += \\\" _insert_abund_map();\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // calculate the atomic_masses of the elements \\\\n\\\"\\n cpp_file += \\\" std::map<int,double> :: iterator it;\\\\n\\\"\\n cpp_file += \\\" \\\\n\\\"\\n cpp_file += \\\" for (int z = 1; z <= 92 ; z++) {\\\\n\\\"\\n cpp_file += \\\" // loop through the natural abundance map\\\\n\\\"\\n cpp_file += \\\" double element_atomic_weight = 0.0;\\\\n\\\"\\n cpp_file += \\\" for (it = natural_abund_map.begin(); it != natural_abund_map.end() ; ++it){\\\\n\\\"\\n cpp_file += \\\" // if the atomic number of the abudance matches the\\\\n\\\"\\n cpp_file += \\\" // that of index\\\\n\\\"\\n cpp_file += \\\" if(pyne::nucname::znum(it->first) == z) {\\\\n\\\"\\n cpp_file += \\\" // take atomic abundance and multiply by mass\\\\n\\\"\\n cpp_file += (\\n \\\" // to get the mass of that nuclide / 100 since abundance is in %\\\\n\\\"\\n )\\n cpp_file += \\\" element_atomic_weight += (it->second*atomic_mass_map[it->first]/100.0);\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\" // insert the abundance of the element into the list\\\\n\\\"\\n cpp_file += \\\" atomic_mass_map[z*10000000] = element_atomic_weight;\\\\n\\\"\\n cpp_file += \\\" }\\\\n\\\"\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_atomic_mass_map() { \\\\n\\\"\\n cpp_file += generate_atomic_mass()\\n cpp_file += \\\"}\\\\n\\\"\\n cpp_file += \\\"\\\\n\\\\n\\\"\\n cpp_file += \\\"void pyne::_insert_abund_map() { \\\\n\\\"\\n cpp_file += generate_abundances()\\n cpp_file += \\\"}\\\\n\\\"\\n return cpp_file\",\n \"def compile(self, exclude=None, recurse=True, references=None, verbose=False):\\n from clay.shell.core import lsgrep\\n\\n _os.chdir(self.directory)\\n sources = self.sources\\n\\n if sources is None:\\n sources = [_os.path.splitext(x)[0] for x in lsgrep(self.src_ext, self.directory, recurse=recurse)]\\n if exclude is not None and len(exclude) > 0:\\n sources = list(filter(lambda x: all(not(y in x) for y in exclude), sources))\\n # if any flags, include them\\n if len(self.flags) > 0:\\n opt_str = '-' + ' -'.join(self.flags)\\n else:\\n opt_str = ''\\n\\n statechanged = False\\n for src in sources:\\n src_name = src + self.src_ext\\n dst_name = src + self.dst_ext\\n\\n if not _os.path.exists(src_name):\\n print(src, 'doesn\\\\'t exist, skipping...')\\n continue\\n\\n src_mtime = _os.stat(src_name).st_mtime\\n if _os.path.exists(dst_name):\\n dst_mtime = _os.stat(dst_name).st_mtime\\n else:\\n dst_mtime = 0 # file doesn't exist\\n\\n # if edited more than five seconds ago, compile it\\n if src_mtime - dst_mtime >= 5:\\n print('Compiling ({}):'.format(self.compiler_name), src)\\n cmd = self.compiler_name\\n if self.compiler_name == 'csc': # C Sharp specific handling\\n if references is not None:\\n cmd += ' /r:' + ','.join(references)\\n cmd += ' /out:{} '.format(dst_name)\\n cmd += '{} \\\"{}\\\"'.format(opt_str, src_name)\\n if verbose:\\n print('cmd:', cmd)\\n _os.system(cmd)\\n statechanged = True\\n\\n if not statechanged:\\n print('Nothing new to compile in \\\"{}\\\" when recurse={}'.format(self.directory, recurse))\",\n \"def compile(self, args):\\n if args not in self._compileinfos:\\n cres = compile_with_dppl(self.py_func, None, args, debug=self.debug)\\n func = cres.library.get_function(cres.fndesc.llvm_func_name)\\n cres.target_context.mark_ocl_device(func)\\n first_definition = not self._compileinfos\\n self._compileinfos[args] = cres\\n libs = [cres.library]\\n\\n if first_definition:\\n # First definition\\n cres.target_context.insert_user_function(self, cres.fndesc,\\n libs)\\n else:\\n cres.target_context.add_user_function(self, cres.fndesc, libs)\\n\\n else:\\n cres = self._compileinfos[args]\\n\\n return cres.signature\",\n \"def gpp_compile_object(\\n source_path: Path,\\n *source_paths: Path,\\n destination_path: Path,\\n gpp_options: Iterable[str] = (),\\n timeout: float = None) -> Tuple[SetupResult, Optional[ExecutableFile]]:\\n\\n destination_path.parent.mkdir(parents=True, exist_ok=True)\\n runtime = process.run(\\n \\\"g++\\\",\\n str(source_path),\\n *map(str, source_paths),\\n *gpp_options,\\n \\\"-o\\\", str(destination_path),\\n timeout=timeout)\\n\\n error_description = None\\n error_traceback = None\\n if runtime.raised_exception:\\n error_description = f\\\"error invoking compilation of {source_path.parts[-1]}: {runtime.exception.description}\\\"\\n elif runtime.timed_out:\\n error_description = f\\\"timed out while compiling {source_path.parts[-1]}\\\"\\n elif runtime.code != 0:\\n if runtime.stderr:\\n error_description = \\\"failed to compile\\\"\\n error_traceback = runtime.stderr.decode(errors=\\\"replace\\\")\\n else:\\n error_description = \\\"nonzero status code during compilation\\\"\\n elif not destination_path.exists():\\n error_description = f\\\"build did not produce {destination_path.parts[-1]}\\\"\\n\\n # If the build failed\\n if error_description is not None:\\n error = Error(description=error_description, traceback=error_traceback)\\n return SetupResult(passing=False, details=dict(runtime=runtime.dump()), error=error), None\\n\\n # Chmod\\n add_mode(destination_path, stat.S_IXOTH)\\n\\n # Otherwise\\n return SetupResult(passing=True, details=dict(runtime=runtime.dump())), ExecutableFile(destination_path)\",\n \"def compile_module(self, ExtensionTemplate, main_src, name, extra_sources):\\n from distutils.core import Extension\\n filename = self._expand(ExtensionTemplate, name, main_src)\\n sources = [str(filename)]\\n for i, src in enumerate(extra_sources):\\n extra_filename = self._expand(ExtensionTemplate, 'extmod_%d' % i, src)\\n sources.append(extra_filename)\\n #\\n if sys.platform == 'win32':\\n # not strictly true, could be mingw\\n compile_args = [\\n '/Od',\\n '/WX', # turn warnings into errors (all, for now)\\n # '/Wall', # this is too aggresive, makes windows itself fail\\n '/Zi',\\n '-D_CRT_SECURE_NO_WARNINGS', # something about _snprintf and _snprintf_s\\n '/FS', # Since the tests run in parallel\\n ]\\n link_args = [\\n '/DEBUG',\\n '/LTCG',\\n ]\\n else:\\n compile_args = [\\n '-g', '-O0',\\n '-Wfatal-errors', # stop after one error (unrelated to warnings)\\n '-Werror', # turn warnings into errors (all, for now)\\n ]\\n link_args = [\\n '-g',\\n ]\\n #\\n ext = Extension(\\n name,\\n sources=sources,\\n include_dirs=self.extra_include_dirs,\\n extra_compile_args=compile_args,\\n extra_link_args=link_args)\\n\\n hpy_abi = self.hpy_abi\\n if hpy_abi == 'debug':\\n # there is no compile-time difference between universal and debug\\n # extensions. The only difference happens at load time\\n hpy_abi = 'universal'\\n so_filename = c_compile(str(self.tmpdir), ext,\\n hpy_devel=self.hpy_devel,\\n hpy_abi=hpy_abi,\\n compiler_verbose=self.compiler_verbose)\\n return so_filename\",\n \"def Cpp_test():\\n pass\",\n \"def byte_compile(py_files, optimize=0, force=0, prefix=None, base_dir=None,\\n verbose=1, dry_run=0, direct=None):\\n # nothing is done if sys.dont_write_bytecode is True\\n if hasattr(sys, 'dont_write_bytecode') and sys.dont_write_bytecode:\\n raise DistutilsByteCompileError('byte-compiling is disabled.')\\n\\n # First, if the caller didn't force us into direct or indirect mode,\\n # figure out which mode we should be in. We take a conservative\\n # approach: choose direct mode *only* if the current interpreter is\\n # in debug mode and optimize is 0. If we're not in debug mode (-O\\n # or -OO), we don't know which level of optimization this\\n # interpreter is running with, so we can't do direct\\n # byte-compilation and be certain that it's the right thing. Thus,\\n # always compile indirectly if the current interpreter is in either\\n # optimize mode, or if either optimization level was requested by\\n # the caller.\\n if direct is None:\\n direct = (__debug__ and optimize == 0)\\n\\n # \\\"Indirect\\\" byte-compilation: write a temporary script and then\\n # run it with the appropriate flags.\\n if not direct:\\n from tempfile import mkstemp\\n script_fd, script_name = mkstemp(\\\".py\\\")\\n log.info(\\\"writing byte-compilation script '%s'\\\", script_name)\\n if not dry_run:\\n if script_fd is not None:\\n script = os.fdopen(script_fd, \\\"w\\\")\\n else:\\n script = open(script_name, \\\"w\\\")\\n\\n try:\\n script.write(\\\"\\\"\\\"\\\\\\nfrom distutils2.util import byte_compile\\nfiles = [\\n\\\"\\\"\\\")\\n\\n # XXX would be nice to write absolute filenames, just for\\n # safety's sake (script should be more robust in the face of\\n # chdir'ing before running it). But this requires abspath'ing\\n # 'prefix' as well, and that breaks the hack in build_lib's\\n # 'byte_compile()' method that carefully tacks on a trailing\\n # slash (os.sep really) to make sure the prefix here is \\\"just\\n # right\\\". This whole prefix business is rather delicate -- the\\n # problem is that it's really a directory, but I'm treating it\\n # as a dumb string, so trailing slashes and so forth matter.\\n\\n #py_files = map(os.path.abspath, py_files)\\n #if prefix:\\n # prefix = os.path.abspath(prefix)\\n\\n script.write(\\\",\\\\n\\\".join(map(repr, py_files)) + \\\"]\\\\n\\\")\\n script.write(\\\"\\\"\\\"\\nbyte_compile(files, optimize=%r, force=%r,\\n prefix=%r, base_dir=%r,\\n verbose=%r, dry_run=0,\\n direct=1)\\n\\\"\\\"\\\" % (optimize, force, prefix, base_dir, verbose))\\n\\n finally:\\n script.close()\\n\\n cmd = [sys.executable, script_name]\\n if optimize == 1:\\n cmd.insert(1, \\\"-O\\\")\\n elif optimize == 2:\\n cmd.insert(1, \\\"-OO\\\")\\n\\n env = copy(os.environ)\\n env['PYTHONPATH'] = ':'.join(sys.path)\\n try:\\n spawn(cmd, dry_run=dry_run, env=env)\\n finally:\\n execute(os.remove, (script_name,), \\\"removing %s\\\" % script_name,\\n dry_run=dry_run)\\n\\n # \\\"Direct\\\" byte-compilation: use the py_compile module to compile\\n # right here, right now. Note that the script generated in indirect\\n # mode simply calls 'byte_compile()' in direct mode, a weird sort of\\n # cross-process recursion. Hey, it works!\\n else:\\n from py_compile import compile\\n\\n for file in py_files:\\n if file[-3:] != \\\".py\\\":\\n # This lets us be lazy and not filter filenames in\\n # the \\\"install_lib\\\" command.\\n continue\\n\\n # Terminology from the py_compile module:\\n # cfile - byte-compiled file\\n # dfile - purported source filename (same as 'file' by default)\\n cfile = file + (__debug__ and \\\"c\\\" or \\\"o\\\")\\n dfile = file\\n if prefix:\\n if file[:len(prefix)] != prefix:\\n raise ValueError(\\\"invalid prefix: filename %r doesn't \\\"\\n \\\"start with %r\\\" % (file, prefix))\\n dfile = dfile[len(prefix):]\\n if base_dir:\\n dfile = os.path.join(base_dir, dfile)\\n\\n cfile_base = os.path.basename(cfile)\\n if direct:\\n if force or newer(file, cfile):\\n log.info(\\\"byte-compiling %s to %s\\\", file, cfile_base)\\n if not dry_run:\\n compile(file, cfile, dfile)\\n else:\\n log.debug(\\\"skipping byte-compilation of %s to %s\\\",\\n file, cfile_base)\",\n \"def compile_functions_to_c(self, functions, externs=[]):\\n # Mangle main function: real main is provided by libv\\n for function in functions:\\n if function.signature.name == \\\"main\\\":\\n function.signature.name = \\\"vizh_main\\\"\\n\\n signature_list = externs + [function.signature for function in functions]\\n \\n # We need size_t and libv functions\\n code = ['#include <stddef.h>',\\n '#include \\\"libv.h\\\"']\\n\\n # First output forward declarations for all functions and externs\\n code += [f'{str(signature)};' for signature in signature_list]\\n\\n signature_list += libv_decls\\n signatures = {signature.name: signature for signature in signature_list}\\n\\n errors = []\\n for function in functions:\\n try:\\n code.append(self.compile_function_to_c(function, signatures))\\n except CompilerError as err:\\n errors.append((function.signature.name,err))\\n\\n if len(errors) > 0:\\n messages = [f'Error while compiling {func_name}: {err}' for func_name, err in errors]\\n raise CompilerError('\\\\n'.join(messages))\\n \\n return '\\\\n'.join(code)\",\n \"def compile (self):\\n print(\\\"*** compiling the inno setup script ***\\\")\\n progpath = get_nt_platform_vars()[0]\\n cmd = r'%s\\\\Inno Setup 5\\\\iscc.exe' % progpath\\n subprocess.check_call([cmd, self.pathname])\",\n \"def compile(self):\\n return None # pragma: no cover\",\n \"def c2o(source_file, target_file):\\n import time\\n import subprocess as sp\\n\\n #object_file = target_file + '_NoZOLandVLIW.o'\\n object_file = target_file + '.o'\\n middle_file = target_file + '.ll'\\n asm_file = target_file + '.s'\\n\\n stderr_mid = None\\n stderr_asm = None\\n stderr_obj = None\\n\\n start = time.perf_counter()\\n cmd = [CLANG, source_file, '-o', middle_file] + CLANG_PARAMETER\\n print('Generating .ll file...')\\n\\n try:\\n completed_process = sp.run(cmd, stdout=sp.PIPE, stderr=sp.PIPE,\\n universal_newlines=True)\\n print('Done!')\\n stderr_mid = completed_process.stderr\\n\\n cmd = [LLC, middle_file, '-filetype=asm','-o', asm_file] + LLC_PARAMETER\\n print('Generating asm file...')\\n completed_process = sp.run(cmd, stdout=sp.PIPE, stderr=sp.PIPE,\\n universal_newlines=True)\\n print('Done!')\\n stderr_asm = completed_process.stderr\\n\\n if completed_process.returncode == 0:\\n cmd = [LLC, middle_file, '-filetype=obj', '-o', object_file] + LLC_PARAMETER\\n print('Generating obj file...')\\n completed_process = sp.run(cmd, stdout=sp.PIPE, stderr=sp.PIPE,\\n universal_newlines=True)\\n print('Done!')\\n stderr_obj = completed_process.stderr\\n\\n try:\\n operation(asm_file, object_file)\\n change_machine_code(object_file)\\n except FileNotFoundError as error:\\n print(error)\\n return (None, source_file)\\n except ValueError:\\n return (False, source_file)\\n else:\\n return (True,)\\n finally:\\n elapsed = time.perf_counter() - start\\n with open(LOG_FILE, mode='a', newline=None) as log:\\n sentence = '%s:\\\\nTime Elapsed %fs\\\\n' % (\\n os.path.basename(source_file), elapsed)\\n log.write(sentence)\\n try:\\n sentence = '\\\\n指令个数：%d\\\\t平均耗时：%fs\\\\n\\\\n' % (INST_NUM, elapsed / INST_NUM)\\n log.write(sentence)\\n except ZeroDivisionError:\\n log.write('读取ASM文件中的指令出错')\\n else:\\n return (None, source_file)\\n except OSError as error:\\n print('\\\\n', cmd[0], '调用错误 :', error)\\n return (None, source_file)\\n finally:\\n if stderr_mid is not None or stderr_asm is not None or stderr_obj is not None:\\n with open(target_file + '.log', mode='w', newline=None) as log:\\n if stderr_mid is not None:\\n log.write('\\\\n#####==========stderr_mid==========#####:\\\\n')\\n log.write(stderr_mid)\\n if stderr_asm is not None:\\n log.write('\\\\n#####==========stderr_asm==========#####:\\\\n')\\n log.write(stderr_asm)\\n if stderr_obj is not None:\\n log.write('\\\\n#####==========stderr_obj==========#####:\\\\n')\\n log.write(stderr_obj)\",\n \"def binary_compile_cmd(self):\\n ld = self.nvcc_options_json[\\\"ld\\\"]\\n objcopy = self.nvcc_options_json[\\\"objcopy\\\"]\\n cmd = \\\" \\\".join([ld, \\\"-r -b binary -o {target} {src}\\\"])\\n # Support models with >2GB constants on Linux only\\n if is_linux():\\n cmd += (\\n f\\\" && {objcopy} --rename-section\\\"\\n \\\" .data=.lrodata,alloc,load,readonly,data,contents\\\"\\n \\\" {target} {target}\\\"\\n )\\n return cmd\",\n \"def isomif_compile():\\n subprocess.check_output(['gcc', str(Path(GET_CLEFT_PATH) / 'Get_Cleft.c'),\\n '-o', str(Path(GET_CLEFT_PATH) / 'Get_Cleft'),\\n '-O3', '-lm',\\n ])\\n print('Get_Cleft compiled')\\n # Compile MIF and IsoMIF for linux_x86_64, needs path to gsl\\n subprocess.check_output(['g++', str(Path(ISOMIF_PATH) / 'mif.cpp'),\\n '-o', str(Path(ISOMIF_PATH) / MIF_NAME),\\n '-O3', '-lm',\\n ])\\n print('MIF compiled')\\n subprocess.check_output(['g++', str(Path(ISOMIF_PATH) / 'isomif.cpp'),\\n '-o', str(Path(ISOMIF_PATH) / ISOMIF_NAME),\\n '-O3', '-lm', '-lgsl', '-lgslcblas', '-L', str(Path(GSL_PATH) / 'lib'),\\n '-I', str(Path(GSL_PATH) / 'include'),\\n ])\\n print('IsoMIF compiled')\",\n \"def test_py_compile_basic(self):\\n self._test_py_compile('basic')\",\n \"def main(args=()):\\n header = generate_header()\\n source = generate_cpp()\\n write_if_diff(\\\"atomic_data.h\\\", header)\\n write_if_diff(\\\"atomic_data.cpp\\\", source)\",\n \"def build_compiler_flags(petsc_dir, petsc_arch, extra_compiler_flags=None, verbose=False):\\n if extra_compiler_flags is None:\\n extra_compiler_flags = []\\n\\n misc_flags = [\\n '-DPETSC_CLANG_STATIC_ANALYZER',\\n '-xc++',\\n '-Wno-empty-body',\\n '-Wno-writable-strings',\\n '-Wno-array-bounds',\\n '-Wno-nullability-completeness',\\n '-fparse-all-comments',\\n '-g'\\n ]\\n petsc_includes = get_petsc_extra_includes(petsc_dir, petsc_arch)\\n compiler_flags = get_clang_sys_includes() + misc_flags + petsc_includes + extra_compiler_flags\\n if verbose:\\n pl.sync_print('\\\\n'.join(['Compile flags:', *compiler_flags]))\\n return compiler_flags\",\n \"def setup_gcc():\\n if not os.path.exists(gcc_build_dir):\\n docmd(\\\"mkdir %s\\\" % gcc_build_dir)\\n dochdir(gcc_build_dir)\\n dopt = \\\"\\\"\\n if flag_debug_gcc:\\n dopt = mk_debug_configopts()\\n sropt = \\\"\\\"\\n if sysroot:\\n sropt = \\\"--with-sysroot=%s\\\" % sysroot\\n else:\\n if flag_do_only_gcc_build:\\n sropt = \\\"\\\"\\n else:\\n sropt = \\\"--with-glibc-version=2.20\\\"\\n doscmd(\\\"../%s/configure %s --prefix=%s --target=%s %s \\\"\\n \\\"--enable-languages=%s --enable-libgo \\\"\\n \\\"%s %s \\\" % (flag_gcc_subdir,\\n dopt, cross_prefix,\\n flag_target_arch,\\n sropt, flag_langs,\\n flag_use_multilib, flag_use_bootstrap))\\n doscmd(\\\"make %s all-gcc\\\" % flag_parfactor)\\n doscmd(\\\"make %s install-gcc\\\" % flag_parfactor)\\n dochdir(\\\"..\\\")\",\n \"def try_compile(compiler, code=None, flags=[], ext=None):\\n from distutils.errors import CompileError\\n from numpy.distutils.fcompiler import FCompiler\\n\\n if code is None:\\n if isinstance(compiler, FCompiler):\\n code = \\\" program main\\\\n return\\\\n end\\\"\\n else:\\n code = 'int main (int argc, char **argv) { return 0; }'\\n\\n ext = ext or compiler.src_extensions[0]\\n\\n with tempfile.TemporaryDirectory() as temp_dir:\\n fname = os.path.join(temp_dir, 'main'+ext)\\n with open(fname, 'w') as f:\\n f.write(code)\\n\\n try:\\n compiler.compile([fname], output_dir=temp_dir, extra_postargs=flags)\\n except CompileError:\\n return False\\n return True\",\n \"def compile_coffeescript(*files):\\r\\n if not files:\\r\\n files = [\\\"`{}`\\\".format(coffeescript_files())]\\r\\n sh(cmd(\\r\\n \\\"node_modules/.bin/coffee\\\", \\\"--compile\\\", *files\\r\\n ))\",\n \"def compile_src(source):\\n result_tuple = compile_source(source, get_preprocessor(), get_grammar(), get_transformer(),\\n get_compiler())\\n return result_tuple\",\n \"def compile_src(source):\\n result_tuple = compile_source(source, get_preprocessor(), get_grammar(), get_transformer(),\\n get_compiler())\\n return result_tuple\",\n \"def compile_src(source):\\n result_tuple = compile_source(source, get_preprocessor(), get_grammar(), get_transformer(),\\n get_compiler())\\n return result_tuple\",\n \"def compile(self):\\n raise NotImplementedError()\",\n \"def __init__(self, code=\\\"\\\", lang=\\\"\\\", input=\\\"\\\", id=0):\\n self.code = code\\n self.lang = lang\\n self.input = input\\n self.id = str(id)\\n self.output = \\\"\\\"\\n self.status = \\\"\\\"\\n self.create_file()\\n if(self.lang == \\\"PYTHON\\\"):\\n self.compile_python()\\n elif(self.lang == \\\"C\\\"):\\n self.compile_c()\\n elif(self.lang == \\\"CPP\\\"):\\n self.compile_cpp()\\n elif(self.lang == \\\"JAVA\\\"): # For Java File \\n self.compile_java()\\n elif(self.lang==\\\"JS\\\"):\\n self.compile_js()\\n self.delete_file()\",\n \"def compile_build_files(ctx):\\n project_dir = Path(__file__).parent\\n\\n build_dir = project_dir / \\\"build\\\"\\n ninja_dir = project_dir / \\\"build/ninja\\\"\\n artifacts_dir = project_dir / \\\"build/artifacts\\\"\\n\\n if artifacts_dir.exists():\\n shutil.rmtree(artifacts_dir)\\n if ninja_dir.exists():\\n shutil.rmtree(ninja_dir)\\n\\n os.makedirs(artifacts_dir)\\n os.makedirs(ninja_dir)\\n\\n call_cmake = (\\n f\\\"cmake \\\"\\n f\\\"-DCMAKE_BUILD_TYPE=Release \\\"\\n f'-G Ninja \\\"{build_dir}\\\" '\\n f\\\"-DPYTHON_EXECUTABLE={sys.executable} \\\"\\n )\\n call_ninja = \\\"ninja -j 8\\\"\\n call_install = \\\"ninja install\\\"\\n\\n with ctx.cd(str(project_dir / \\\"build/ninja\\\")):\\n if sys.platform == \\\"win32\\\":\\n paths = (\\n os.path.expandvars(\\n r\\\"${PROGRAMFILES(X86)}\\\\Microsoft Visual Studio\\\\2017\\\\Community\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\\\"\\n ),\\n os.path.expandvars(\\n r\\\"${PROGRAMFILES(X86)}\\\\Microsoft Visual Studio\\\\2017\\\\BuildTools\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\\\"\\n ),\\n os.path.expandvars(\\n r\\\"${PROGRAMFILES(X86)}\\\\Microsoft Visual Studio\\\\2017\\\\Professional\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\\\"\\n ),\\n os.path.expandvars(\\n r\\\"${PROGRAMFILES(X86)}\\\\Microsoft Visual Studio\\\\2017\\\\WDExpress\\\\VC\\\\Auxiliary\\\\Build\\\\vcvarsall.bat\\\"\\n ),\\n # Path for vcvars on GithubAction\\n r\\\"C:\\\\Program Files (x86)\\\\Microsoft Visual Studio\\\\2019\\\\Enterprise\\\\VC\\\\Auxiliary\\\\Build\\\\vcvars64.bat\\\",\\n )\\n for msvc_path in paths:\\n if os.path.isfile(msvc_path):\\n break\\n else:\\n raise RuntimeError(\\n \\\"Couldn't find MSVC compiler in any of:\\\\n{}\\\".format(\\\"- \\\" + \\\"\\\\n- \\\".join(paths))\\n )\\n\\n call_cmd = f'call \\\"{msvc_path}\\\" amd64'\\n ctx.run(command=call_cmd + \\\"&\\\" + call_cmake + \\\"&&\\\" + call_ninja + \\\"&&\\\" + call_install)\\n\\n else:\\n ctx.run(command=call_cmake + \\\"&&\\\" + call_ninja + \\\"&&\\\" + call_install)\",\n \"def customize_compiler(compiler):\\n if compiler.compiler_type == \\\"unix\\\":\\n if sys.platform == \\\"darwin\\\":\\n # Perform first-time customization of compiler-related\\n # config vars on OS X now that we know we need a compiler.\\n # This is primarily to support Pythons from binary\\n # installers. The kind and paths to build tools on\\n # the user system may vary significantly from the system\\n # that Python itself was built on. Also the user OS\\n # version and build tools may not support the same set\\n # of CPU architectures for universal builds.\\n global _config_vars\\n # Use get_config_var() to ensure _config_vars is initialized.\\n if not get_config_var('CUSTOMIZED_OSX_COMPILER'):\\n import _osx_support\\n _osx_support.customize_compiler(_config_vars)\\n _config_vars['CUSTOMIZED_OSX_COMPILER'] = 'True'\\n\\n (cc, cxx, opt, cflags, ccshared, ldshared, shlib_suffix, ar, ar_flags) = \\\\\\n get_config_vars('CC', 'CXX', 'OPT', 'CFLAGS',\\n 'CCSHARED', 'LDSHARED', 'SHLIB_SUFFIX', 'AR', 'ARFLAGS')\\n\\n if 'CC' in os.environ:\\n newcc = os.environ['CC']\\n if (sys.platform == 'darwin'\\n and 'LDSHARED' not in os.environ\\n and ldshared.startswith(cc)):\\n # On OS X, if CC is overridden, use that as the default\\n # command for LDSHARED as well\\n ldshared = newcc + ldshared[len(cc):]\\n cc = newcc\\n if 'CXX' in os.environ:\\n cxx = os.environ['CXX']\\n if 'LDSHARED' in os.environ:\\n ldshared = os.environ['LDSHARED']\\n if 'CPP' in os.environ:\\n cpp = os.environ['CPP']\\n else:\\n cpp = cc + \\\" -E\\\" # not always\\n if 'LDFLAGS' in os.environ:\\n ldshared = ldshared + ' ' + os.environ['LDFLAGS']\\n if 'CFLAGS' in os.environ:\\n cflags = opt + ' ' + os.environ['CFLAGS']\\n ldshared = ldshared + ' ' + os.environ['CFLAGS']\\n if 'CPPFLAGS' in os.environ:\\n cpp = cpp + ' ' + os.environ['CPPFLAGS']\\n cflags = cflags + ' ' + os.environ['CPPFLAGS']\\n ldshared = ldshared + ' ' + os.environ['CPPFLAGS']\\n if 'AR' in os.environ:\\n ar = os.environ['AR']\\n if 'ARFLAGS' in os.environ:\\n archiver = ar + ' ' + os.environ['ARFLAGS']\\n else:\\n archiver = ar + ' ' + ar_flags\\n\\n cc_cmd = cc + ' ' + cflags\\n compiler.set_executables(\\n preprocessor=cpp,\\n compiler=cc_cmd,\\n compiler_so=cc_cmd + ' ' + ccshared,\\n compiler_cxx=cxx,\\n linker_so=ldshared,\\n linker_exe=cc,\\n archiver=archiver)\\n\\n compiler.shared_lib_extension = shlib_suffix\",\n \"def main():\\n print(\\n \\\"\\\"\\\"\\n\\n ##########################################################\\n # #\\n # #\\n # Compiling Colocalized Cyano Datasets #\\n # #\\n # #\\n ##########################################################\\n\\n \\n \\\"\\\"\\\"\\n )\\n cyanoFiles = glob.glob(f\\\"{COLOCALIZED_DIR}*.csv\\\")\\n makedir(COMPILED_DIR)\\n dfCompiled = pd.DataFrame({})\\n for cyanoFile in cyanoFiles:\\n print(f\\\"Compiling {cyanoFile}\\\")\\n data = unify(cyanoFile)\\n if len(dfCompiled ) < 1:\\n dfCompiled = data\\n else:\\n dfCompiled = pd.concat([dfCompiled, data], ignore_index=True) \\n dfCompiled.to_csv(f\\\"{COMPILED_DIR}compiled.csv\\\", index=False)\",\n \"def decompile():\\n #list of files to decompile and results decompile\\n dataprocessor_files = []\\n\\n #list of files to decompile and results decompile for 1C v7.7\\n dataprocessor_files_v7 = []\\n\\n #list of files to decompile and results decompile for 1C MD\\n dataprocessor_files_MD = []\\n\\n #set the exit code\\n exit_code = 0\\n\\n #Find datapocessor files\\n for filename in get_list_of_comitted_files():\\n #Check the file extensions\\n logging.info(\\\"file to check %s\\\" % filename)\\n if filename[-3:] == \\\"ert\\\":\\n dataprocessor_files_v7.append(filename)\\n logging.info(\\\"file %s\\\" % filename)\\n continue \\n if filename[-3:] in ['.MD','.md']:\\n dataprocessor_files_MD.append(filename)\\n logging.info(\\\"file %s\\\" % filename)\\n continue \\n\\n dirsource = os.path.abspath(os.path.join(os.path.curdir, \\\"src\\\"))\\n curabsdirpath = os.path.abspath(os.path.curdir) \\n\\n if len(dataprocessor_files) > 0:\\n #pathbin1c = \\\"C:\\\\\\\\Program Files\\\\\\\\1cv82\\\\8.2.17.153\\\\\\\\bin\\\\\\\\1cv8.exe\\\"\\n #pathbin1c = \\\"c:\\\\\\\\Program Files (x86)\\\\\\\\1cv8\\\\\\\\8.3.4.304\\\\\\\\bin\\\\\\\\1cv8.exe\\\"\\n pathbin1c = get_path_to_1c()\\n\\n if len(dataprocessor_files_v7) > 0:\\n for filename in dataprocessor_files_v7:\\n print(\\\"ert file %s\\\" % filename)\\n #TODO: добавить копирование этих же файлов в каталог src/имяфайла/...\\n #get file name.\\n fullpathfile = os.path.abspath(filename)\\n basename = os.path.splitext(os.path.basename(filename))[0]\\n fullbasename = os.path.basename(filename)\\n newdirname = os.path.dirname(filename)\\n\\n print(\\\"ert file %s\\\" % fullpathfile )\\n\\n #Скопируем сначало просто структуру каталогов.\\n if not os.path.exists(dirsource):\\n os.makedirs(dirsource)\\n #для каждого файла определим новую папку.\\n newsourcepath = os.path.join(dirsource, newdirname)\\n newpath2 = os.path.join(newsourcepath, basename)\\n if not os.path.exists(newsourcepath):\\n logging.info(\\\"create new dir %s\\\" % newsourcepath)\\n os.makedirs(newsourcepath)\\n #print(\\\"curabsdirpath %s\\\" % curabsdirpath)\\n #print(\\\"newpath2 %s\\\" % newpath2)\\n #print(\\\"basename %s\\\" % basename)\\n\\n t1 = format(\\\"gcomp -q -d -F %s -D %s -v --no-ini --no-version --no-empty-mxl\\\" % (filename, newsourcepath))\\n result = subprocess.check_call(['cmd.exe', '/C', t1]) \\n #изменим кодировку cp1251 на utf-8 \\n #утилита iconv.exe должна запускаться в cmd = добавлена в PATH\\t\\t\\t\\n #файлов 1s, mdp, frm, txt\\n t3 = 'bash .git/hooks/convert_utf8.sh {0}'.format( newpath2 )\\n print(\\\"t3 = %s\\\" % t3)\\n logging.info(\\\"CONVERT: %s\\\" % t3)\\n result = subprocess.check_call(['cmd.exe', '/C', t3])\\n #result = subprocess.check_call(['git', 'add', '--all', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.1s', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.frm', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.mxl', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.utf', newsourcepath])\\n if not result == 0:\\n logging.error(result)\\n exit(result)\\n\\n if len(dataprocessor_files_MD) > 0:\\n for filename in dataprocessor_files_MD:\\n print(\\\"MD file %s\\\" % filename)\\n #TODO: добавить копирование этих же файлов в каталог src/имяфайла/...\\n #get file name.\\n fullpathfile = os.path.abspath(filename)\\n basename = os.path.splitext(os.path.basename(filename))[0]\\n fullbasename = os.path.basename(filename)\\n newdirname = os.path.dirname(filename)\\n \\n #Скопируем сначало просто структуру каталогов.\\n if not os.path.exists(dirsource):\\n os.makedirs(dirsource)\\n #для каждого файла определим новую папку.\\n newsourcepath = os.path.join(dirsource, newdirname, \\\"MD\\\")\\n if not os.path.exists(newsourcepath):\\n logging.info(\\\"create new dir %s\\\" % newsourcepath)\\n os.makedirs(newsourcepath)\\n newpath2 = os.path.join(newsourcepath, basename)\\n print(\\\"fullbasename %s\\\" % fullbasename)\\n print(\\\"newdirname %s\\\" % newdirname)\\n print(\\\"newsourcepath %s\\\" % newsourcepath)\\n \\n t1 = format(\\\"gcomp -d -v -F %s -D %s\\\" % (filename, newsourcepath))\\n result = subprocess.check_call(['cmd.exe', '/C', t1])\\n\\n #изменим кодировку cp1251 на utf-8 \\n #утилита iconv.exe должна запускаться в cmd = добавлена в PATH\\t\\t\\t\\n #файлов 1s, mdp, frm, txt\\n t3 = 'bash .git/hooks/convert_utf8.sh {0}'.format( newsourcepath )\\n print(\\\"t3 = %s\\\" % t3)\\n logging.info(\\\"CONVERT: %s\\\" % t3)\\n result = subprocess.check_call(['cmd.exe', '/C', t3])\\n\\n #result = subprocess.check_call(['git', 'add', '--all', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.1s', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.frm', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.mxl', newsourcepath])\\n result = subprocess.check_call(['git', 'add', '*.utf', newsourcepath])\\n if not result == 0:\\n logging.error(result)\\n exit(result)\",\n \"def build(ctx):\\n generate_build_files(ctx)\\n compile_build_files(ctx)\\n _package_plugins(ctx)\",\n \"def cosmic_compile(c_file_path, logger=init_console_logger(name=\\\"cosmic_compile\\\")):\\n # checks\\n assert(os.path.isfile(c_file_path))\\n assert(\\\".c\\\" == c_file_path[-2:])\\n logger.info(\\\"Compiling...\\\")\\n\\n # clean old header files\\n logger.info(\\\"Cleaning old header files...\\\")\\n previous_h_files = [_ for _ in os.listdir(CRAM_DIR_PATH) if _[-2:] == \\\".h\\\"]\\n for f in previous_h_files:\\n try:\\n os.remove(os.path.join(CRAM_DIR_PATH, f))\\n except Exception as e:\\n logger.warning(\\\"Failed to clean old header files: '{}' could not be deleted: {}\\\".format(f, e))\\n\\n # collect source header files\\n with open(c_file_path, \\\"r\\\") as f:\\n lines = f.read()\\n local_includes = re.findall(r\\\"#include\\\\s{0,1}\\\\\\\".+[^\\\\s]\\\\\\\"\\\", lines)\\n h_filenames = [_[8:].replace('\\\"', '').replace(' ', '') for _ in local_includes]\\n\\n # copy source header files\\n source_dir_path = os.path.join(os.path.dirname(c_file_path))\\n for h_filename in h_filenames:\\n src = os.path.join(source_dir_path, h_filename)\\n dst = os.path.join(CRAM_DIR_PATH, h_filename)\\n try:\\n logger.info(\\\"Copying header file '{}' to '{}' ...\\\".format(src, dst))\\n shutil.copyfile(src, dst)\\n except IOError as e:\\n logger.error(\\\"Header file '{}' was not found. Compilation failed. Error message: {}\\\".format(h_filename, e))\\n logger.error(\\\"Compilation failed\\\")\\n return\\n\\n # compile\\n command = r'\\\"{}\\\" \\\"{}\\\" \\\"{}\\\"'.format(COMPILE_BAT_PATH, CRAM_DIR_PATH, c_file_path)\\n logger.debug(\\\"Executing command: {}\\\".format(command))\\n p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True)\\n std_reader = io.TextIOWrapper(p.stdout, encoding='utf8')\\n err_reader = io.TextIOWrapper(p.stderr, encoding='utf8')\\n\\n while True:\\n # read outputs\\n s_out = std_reader.readline().rstrip()\\n e_out = err_reader.readline().rstrip()\\n\\n # output std output text\\n if s_out != '':\\n logger.info(s_out)\\n\\n # error occurred\\n elif e_out != '':\\n # output entire error then return 1\\n while e_out != '':\\n logger.error(e_out)\\n e_out = err_reader.readline().rstrip()\\n logger.error(\\\"Compilation failed\\\")\\n return 1\\n\\n # process finished\\n elif p.poll() is not None:\\n logger.info(\\\"Compilation successful\\\")\\n return 0\",\n \"def build(obj):\\n\\n err = False\\n\\n if obj.portable:\\n chdir(obj.python_bin_path)\\n # Setup build process\\n process = subprocess.Popen(\\n obj.params,\\n stdout=subprocess.PIPE,\\n stderr=subprocess.STDOUT,\\n shell=False\\n )\\n\\n # Kick off build process\\n print \\\"Building %s...\\\" % obj.app\\n print \\\"Please be patient; this might take a while.\\\\nResults and/or errors will be posted when complete.\\\"\\n output = process.communicate()\\n\\n # Check for bad error code\\n if process.returncode:\\n print >> sys.stderr, \\\"Compilation failed!\\\"\\n err = True\\n\\n # Display output\\n print output[0]\\n\\n return err\",\n \"def build_apple(arch: str, debug: bool = False) -> None:\\n import platform\\n import subprocess\\n from efro.error import CleanError\\n\\n # IMPORTANT; seems we currently wind up building against /usr/local gettext\\n # stuff. Hopefully the maintainer fixes this, but for now I need to\\n # remind myself to blow it away while building.\\n if 'MacBook-Fro' in platform.node():\\n if (subprocess.run('which gettext', shell=True,\\n check=False).returncode == 0):\\n raise CleanError('NEED TO TEMP-KILL GETTEXT')\\n\\n builddir = 'build/python_apple_' + arch + ('_debug' if debug else '')\\n efrotools.run('rm -rf \\\"' + builddir + '\\\"')\\n efrotools.run('mkdir -p build')\\n efrotools.run('git clone '\\n 'git@github.com:pybee/Python-Apple-support.git \\\"' +\\n builddir + '\\\"')\\n os.chdir(builddir)\\n\\n # TEMP: Check out a particular commit while the branch head is broken.\\n # We can actually fix this to use the current one, but something\\n # broke in the underlying build even on old commits so keeping it\\n # locked for now...\\n # efrotools.run('git checkout bf1ed73d0d5ff46862ba69dd5eb2ffaeff6f19b6')\\n efrotools.run(f'git checkout {PYTHON_VERSION_MAJOR}')\\n\\n # On mac we currently have to add the _scproxy module or urllib will\\n # fail.\\n txt = efrotools.readfile('patch/Python/Setup.embedded')\\n if arch == 'mac':\\n txt += ('\\\\n'\\n '# ericf added - mac urllib needs this\\\\n'\\n '_scproxy _scproxy.c '\\n '-framework SystemConfiguration '\\n '-framework CoreFoundation')\\n\\n # Turn off sqlite module. (scratch that; leaving it in.)\\n # txt = efrotools.replace_one(txt, '_sqlite3 -I$(', '#_sqlite3 -I$(')\\n # txt = txt.replace(' _sqlite/', '# _sqlite/')\\n\\n # Turn off xz compression module. (scratch that; leaving it in.)\\n # txt = efrotools.replace_one(txt, '_lzma _', '#_lzma _')\\n\\n # Turn off bzip2 module.\\n txt = efrotools.replace_one(txt, '_bz2 _b', '#_bz2 _b')\\n\\n # Turn off openssl module (only if not doing openssl).\\n if not ENABLE_OPENSSL:\\n txt = efrotools.replace_one(txt, '_hashlib _hashopenssl.c',\\n '#_hashlib _hashopenssl.c')\\n\\n # Turn off various other stuff we don't use.\\n for line in [\\n '_codecs _codecsmodule.c',\\n '_codecs_cn cjkcodecs/_codecs_cn.c',\\n '_codecs_hk cjkcodecs/_codecs_hk.c',\\n '_codecs_iso2022 cjkcodecs/',\\n '_codecs_jp cjkcodecs/_codecs_jp.c',\\n '_codecs_jp cjkcodecs/_codecs_jp.c',\\n '_codecs_kr cjkcodecs/_codecs_kr.c',\\n '_codecs_tw cjkcodecs/_codecs_tw.c',\\n '_lsprof _lsprof.o rotatingtree.c',\\n '_multibytecodec cjkcodecs/multibytecodec.c',\\n '_multiprocessing _multiprocessing/multiprocessing.c',\\n '_opcode _opcode.c',\\n 'audioop audioop.c',\\n 'grp grpmodule.c',\\n 'mmap mmapmodule.c',\\n 'parser parsermodule.c',\\n 'pyexpat expat/xmlparse.c',\\n ' expat/xmlrole.c ',\\n ' expat/xmltok.c ',\\n ' pyexpat.c ',\\n ' -I$(srcdir)/Modules/expat ',\\n ' -DHAVE_EXPAT_CONFIG_H -DUSE_PYEXPAT_CAPI'\\n ' -DXML_DEV_URANDOM',\\n 'resource resource.c',\\n 'syslog syslogmodule.c',\\n 'termios termios.c',\\n '_ctypes_test _ctypes/_ctypes_test.c',\\n '_testbuffer _testbuffer.c',\\n '_testimportmultiple _testimportmultiple.c',\\n '_crypt _cryptmodule.c', # not on android so disabling here too\\n ]:\\n txt = efrotools.replace_one(txt, line, '#' + line)\\n\\n if ENABLE_OPENSSL:\\n\\n # _md5 and _sha modules are normally only built if the\\n # system does not have the OpenSSL libs containing an optimized\\n # version.\\n # Note: seems we still need sha3 or we get errors\\n for line in [\\n '_md5 md5module.c',\\n '_sha1 sha1module.c',\\n # '_sha3 _sha3/sha3module.c',\\n '_sha256 sha256module.c',\\n '_sha512 sha512module.c',\\n ]:\\n txt = efrotools.replace_one(txt, line, '#' + line)\\n else:\\n txt = efrotools.replace_one(txt, '_ssl _ssl.c', '#_ssl _ssl.c')\\n efrotools.writefile('patch/Python/Setup.embedded', txt)\\n\\n txt = efrotools.readfile('Makefile')\\n\\n # Fix a bug where spaces in PATH cause errors (darn you vmware fusion!)\\n txt = efrotools.replace_one(\\n txt, '&& PATH=$(PROJECT_DIR)/$(PYTHON_DIR-macOS)/dist/bin:$(PATH) .',\\n '&& PATH=\\\"$(PROJECT_DIR)/$(PYTHON_DIR-macOS)/dist/bin:$(PATH)\\\" .')\\n\\n # Remove makefile dependencies so we don't build the\\n # libs we're not using.\\n srctxt = '$$(PYTHON_DIR-$1)/dist/lib/libpython$(PYTHON_VER)m.a: '\\n txt = efrotools.replace_one(\\n txt, srctxt, '$$(PYTHON_DIR-$1)/dist/lib/libpython$(PYTHON_VER)m.a: ' +\\n ('build/$2/Support/OpenSSL ' if ENABLE_OPENSSL else '') +\\n 'build/$2/Support/XZ $$(PYTHON_DIR-$1)/Makefile\\\\n#' + srctxt)\\n srctxt = ('dist/Python-$(PYTHON_VER)-$1-support.'\\n '$(BUILD_NUMBER).tar.gz: ')\\n txt = efrotools.replace_one(\\n txt, srctxt,\\n 'dist/Python-$(PYTHON_VER)-$1-support.$(BUILD_NUMBER).tar.gz:'\\n ' $$(PYTHON_FRAMEWORK-$1)\\\\n#' + srctxt)\\n\\n # Turn doc strings on; looks like it only adds a few hundred k.\\n txt = txt.replace('--without-doc-strings', '--with-doc-strings')\\n\\n # Set mac/ios version reqs\\n # (see issue with utimensat and futimens).\\n txt = efrotools.replace_one(txt, 'MACOSX_DEPLOYMENT_TARGET=10.8',\\n 'MACOSX_DEPLOYMENT_TARGET=10.14')\\n # And equivalent iOS (11+).\\n txt = efrotools.replace_one(txt, 'CFLAGS-iOS=-mios-version-min=8.0',\\n 'CFLAGS-iOS=-mios-version-min=12.0')\\n # Ditto for tvOS.\\n txt = efrotools.replace_one(txt, 'CFLAGS-tvOS=-mtvos-version-min=9.0',\\n 'CFLAGS-tvOS=-mtvos-version-min=12.0')\\n\\n if debug:\\n\\n # Add debug build flag\\n # (Currently expect to find 2 instances of this).\\n dline = '--with-doc-strings --enable-ipv6 --without-ensurepip'\\n splitlen = len(txt.split(dline))\\n if splitlen != 3:\\n raise Exception('unexpected configure lines')\\n txt = txt.replace(dline, '--with-pydebug ' + dline)\\n\\n # Debug has a different name.\\n # (Currently expect to replace 12 instances of this).\\n dline = 'python$(PYTHON_VER)m'\\n splitlen = len(txt.split(dline))\\n if splitlen != 13:\\n raise RuntimeError(f'Unexpected configure line count {splitlen}.')\\n txt = txt.replace(dline, 'python$(PYTHON_VER)dm')\\n\\n efrotools.writefile('Makefile', txt)\\n\\n # Ok; let 'er rip.\\n # (we run these in parallel so limit to 1 job a piece;\\n # otherwise they inherit the -j12 or whatever from the top level)\\n # (also this build seems to fail with multiple threads)\\n efrotools.run('make -j1 ' + {\\n 'mac': 'Python-macOS',\\n 'ios': 'Python-iOS',\\n 'tvos': 'Python-tvOS'\\n }[arch])\\n print('python build complete! (apple/' + arch + ')')\",\n \"def compile_files(base, output, source, bind=True, amd=False):\\n\\n # Paths\\n path = lambda *x: r.path(*[base] + list(x))\\n tsc_path = path('node_modules', 'typescript', 'bin', 'tsc.js')\\n output_folder = path(*output)\\n source_folder = path(*source)\\n\\n # Compile each file. Sometimes --module seems to screw up the use\\n # of --out, so safely check and fix if required.\\n def collection(matches, run):\\n for path in matches:\\n output_module_name = os.path.basename(path)[:-3] + '.js'\\n generated_file = os.path.join(source_folder, output_module_name)\\n required_file = os.path.join(output_folder, output_module_name)\\n run('mkdir', '-p', os.path.dirname(required_file))\\n if amd:\\n run('node', tsc_path, path, '--module', 'amd', '--out', required_file)\\n else:\\n run('node', tsc_path, path, '--out', required_file)\\n if os.path.exists(generated_file): # wtf?\\n run('mv', generated_file, required_file)\\n\\n # Build\\n build = r.build()\\n build.notice('Typescript multifile compile')\\n build.chdir(source_folder)\\n build.collect('.*\\\\.ts$', collection)\\n\\n # Target\\n target = r.target(timeout=10)\\n target.pattern('.*[^d]\\\\.ts$', dirname(source_folder), recurse=True)\\n\\n # Bind if required\\n if bind:\\n r.bind(target, build)\\n\\n # Run?\\n if ruffx.BUILD:\\n build.execute()\\n\\n return build\",\n \"def test_clang_cxx(self):\\n self.assertEqual(\\n self.ndk.clang_cxx,\\n f\\\"/opt/android/android-ndk/toolchains/llvm/prebuilt/{self.ndk.host_tag}/bin/clang++\\\",\\n )\",\n \"def compile(c_file: File) -> File:\\n os.system(\\\"gcc -c {c_file}\\\".format(c_file=c_file.path))\\n return File(c_file.path.replace('.c', '.o'))\",\n \"def compile(self):\\n print \\\"+ Nothing to be done ;)\\\"\",\n \"def build(\\n base_filename, src, bsp_c3, crt0_asm, march, opt_level, mmap,\\n lang='c3', bin_format=None, elf_format=None, code_image='code'):\\n list_filename = base_filename + '.html'\\n\\n with HtmlReportGenerator(open(list_filename, 'w')) as reporter:\\n o1 = asm(crt0_asm, march)\\n if lang == 'c3':\\n srcs = [\\n relpath('..', 'librt', 'io.c3'),\\n bsp_c3,\\n io.StringIO(src)]\\n o2 = c3c(\\n srcs, [], march, opt_level=opt_level,\\n reporter=reporter, debug=True)\\n objs = [o1, o2]\\n elif lang == 'bf':\\n o3 = bfcompile(src, march, reporter=reporter)\\n o2 = c3c(\\n [bsp_c3], [], march, reporter=reporter)\\n objs = [o1, o2, o3]\\n elif lang == 'c':\\n o2 = c3c(\\n [bsp_c3], [], march, reporter=reporter)\\n coptions = COptions()\\n include_path1 = relpath('..', 'librt', 'libc')\\n coptions.add_include_path(include_path1)\\n with open(relpath('..', 'librt', 'libc', 'lib.c'), 'r') as f:\\n o3 = cc(\\n f, march, coptions=coptions,\\n reporter=reporter)\\n o4 = cc(\\n io.StringIO(src), march, coptions=coptions,\\n reporter=reporter)\\n objs = [o1, o2, o3, o4]\\n else:\\n raise NotImplementedError('language not implemented')\\n obj = link(\\n objs, layout=mmap,\\n use_runtime=True, reporter=reporter, debug=True)\\n\\n # Save object:\\n obj_file = base_filename + '.oj'\\n with open(obj_file, 'w') as f:\\n obj.save(f)\\n\\n if elf_format:\\n elf_filename = base_filename + '.' + elf_format\\n objcopy(obj, code_image, elf_format, elf_filename)\\n\\n # Export code image to some format:\\n if bin_format:\\n sample_filename = base_filename + '.' + bin_format\\n objcopy(obj, code_image, bin_format, sample_filename)\\n\\n return obj\",\n \"def cuda_compiler_flags():\\n if ('CXX' in os.environ):\\n exe = os.environ['CXX']\\n else:\\n exe = 'g++'\\n gcc_flags = get_gcc_flags(exe)\\n try:\\n gcc_flags.remove('-std=c++11')\\n except:\\n pass\\n gcc_flags += ['-DCUDA_DEBUG']\\n gcc_flags_string = \\\" \\\".join(gcc_flags)\\n nvcc_flags = ['-DCUDA_DEBUG'] # hardly adds overhead, recommended\\n if CAD_DEBUG:\\n nvcc_flags += ['-O0', '-g', '-G']\\n else:\\n if CAD_SAFE_CUDA_FLAGS:\\n nvcc_flags += ['-O2']\\n nvcc_flags += ['-use_fast_math']\\n nvcc_flags += ['--generate-code', 'arch=compute_35,code=compute_35']\\n else:\\n nvcc_flags += ['-O3']\\n nvcc_flags += ['-use_fast_math']\\n # --- create cubin code\\n nvcc_flags += ['--generate-code', 'arch=compute_35,code=sm_35']\\n nvcc_flags += ['--generate-code', 'arch=compute_37,code=sm_37']\\n if (CUDAVER[0] >= 6):\\n nvcc_flags += ['--generate-code', 'arch=compute_50,code=sm_50']\\n if (CUDAVER[0] >= 7):\\n nvcc_flags += ['--generate-code', 'arch=compute_52,code=sm_52']\\n nvcc_flags += ['--generate-code', 'arch=compute_53,code=sm_53']\\n if (CUDAVER[0] >= 8):\\n nvcc_flags += ['--generate-code', 'arch=compute_60,code=sm_60']\\n nvcc_flags += ['--generate-code', 'arch=compute_61,code=sm_61']\\n if (CUDAVER[0] >= 9):\\n nvcc_flags += ['--generate-code', 'arch=compute_70,code=sm_70']\\n if (CUDAVER[0] >= 10):\\n nvcc_flags += ['--generate-code', 'arch=compute_75,code=sm_75']\\n # --- generate PTX code for future compatibility\\n if (CUDAVER[0] == 6):\\n nvcc_flags += ['--generate-code', 'arch=compute_50,code=compute_50']\\n if (CUDAVER[0] == 7):\\n nvcc_flags += ['--generate-code', 'arch=compute_53,code=compute_53']\\n if (CUDAVER[0] == 8):\\n nvcc_flags += ['--generate-code', 'arch=compute_61,code=compute_61']\\n if (CUDAVER[0] == 9):\\n nvcc_flags += ['--generate-code', 'arch=compute_70,code=compute_70']\\n if (CUDAVER[0] == 10):\\n nvcc_flags += ['--generate-code', 'arch=compute_75,code=compute_75']\\n nvcc_flags += ['--compiler-options=' + gcc_flags_string + ' -fPIC']\\n print(\\\"NVCC flags: {}\\\".format(\\\" \\\".join(nvcc_flags)))\\n return {'gcc': gcc_flags, 'nvcc': nvcc_flags}\",\n \"def CustomCompileCheck(context, message, source, extension=\\\".cc\\\"):\\n context.Message(message)\\n\\n env = context.env\\n if env.GetOption(\\\"clean\\\") or env.GetOption(\\\"help\\\") or env.GetOption(\\\"no_exec\\\"):\\n result = True\\n else:\\n result = context.TryCompile(source, extension)\\n\\n context.Result(result)\\n\\n return result\",\n \"def generate(env):\\n # NOTE: SCons requires the use of this name, which fails gpylint.\\n\\n # Set target platform bits\\n env.SetBits('debug')\\n\\n env['TARGET_DEBUG'] = True\\n\\n env.Append(\\n CPPDEFINES=['_DEBUG'] + env.get('CPPDEFINES_DEBUG', []),\\n CCFLAGS=env.get('CCFLAGS_DEBUG', []),\\n LINKFLAGS=env.get('LINKFLAGS_DEBUG', []),\\n )\",\n \"def main(argv):\\n target = argv[1] if len(argv) >= 2 else 'all'\\n if target not in ('all', 'flatbuffers', 'webp', 'clean'):\\n sys.stderr.write('No rule to build target %s.\\\\n' % target)\\n\\n if target in ('all', 'flatbuffers'):\\n try:\\n generate_flatbuffer_binaries()\\n except BuildError as error:\\n handle_build_error(error)\\n return 1\\n if target in ('all', 'webp'):\\n try:\\n generate_webp_textures()\\n except BuildError as error:\\n handle_build_error(error)\\n return 1\\n if target == 'clean':\\n try:\\n clean()\\n except OSError as error:\\n sys.stderr.write('Error cleaning: %s' % str(error))\\n return 1\\n\\n return 0\",\n \"def compile_package(self):\\n build_package = [\\n self.mock,\\n '--root=%s' % self.root,\\n '--arch=%s' % self.arch,\\n '--shell',\\n '/build_package.sh',\\n \\n ]\\n output, errors = self._run_command(build_package)\",\n \"def try_compile_tmp(src_code, tmp_prefix='', flags=(), try_run=False):\\r\\n if not theano.config.cxx:\\r\\n return False\\r\\n\\r\\n flags = list(flags)\\r\\n compilation_ok = True\\r\\n run_ok = False\\r\\n try:\\r\\n fd, path = tempfile.mkstemp(suffix='.c', prefix=tmp_prefix)\\r\\n exe_path = path[:-2]\\r\\n try:\\r\\n # Python3 compatibility: try to cast Py3 strings as Py2 strings\\r\\n try:\\r\\n src_code = b(src_code)\\r\\n except Exception:\\r\\n pass\\r\\n os.write(fd, src_code)\\r\\n os.close(fd)\\r\\n fd = None\\r\\n p_ret = call_subprocess_Popen(\\r\\n ['g++', path, '-o', exe_path] + flags)\\r\\n if p_ret != 0:\\r\\n compilation_ok = False\\r\\n elif try_run:\\r\\n # Try to execute the program\\r\\n try:\\r\\n p_ret = call_subprocess_Popen([exe_path])\\r\\n run_ok = (p_ret == 0)\\r\\n finally:\\r\\n os.remove(exe_path)\\r\\n finally:\\r\\n try:\\r\\n if fd is not None:\\r\\n os.close(fd)\\r\\n finally:\\r\\n os.remove(path)\\r\\n\\r\\n except OSError, e:\\r\\n compilation_ok = False\\r\\n\\r\\n if not try_run:\\r\\n return compilation_ok\\r\\n else:\\r\\n return (compilation_ok, run_ok)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6460845","0.6460845","0.6460829","0.6281568","0.62301815","0.6133531","0.6118104","0.6079851","0.6027266","0.6002802","0.5884031","0.5878032","0.5852781","0.5839785","0.5818881","0.5815626","0.5788101","0.57821906","0.57686496","0.5767464","0.57662016","0.57374066","0.570181","0.56938726","0.5693457","0.5682508","0.56789666","0.56755066","0.56543946","0.5651858","0.5634284","0.5609847","0.5578894","0.5570315","0.5567585","0.5564256","0.556038","0.5558323","0.555567","0.5553563","0.55486023","0.5540778","0.5525631","0.5522256","0.5519523","0.54857254","0.54831356","0.5462947","0.54507065","0.54506415","0.5448494","0.54459846","0.5443149","0.54350674","0.54078525","0.5397158","0.5382301","0.53730667","0.5365979","0.53615135","0.53611565","0.53492355","0.53379345","0.5332028","0.5327576","0.5326515","0.5321841","0.53201735","0.531898","0.5298283","0.5284508","0.5275238","0.5274833","0.5269755","0.5262699","0.5259318","0.52589","0.524938","0.524938","0.524938","0.52478963","0.5245168","0.52442384","0.52376133","0.52260864","0.52238667","0.5219364","0.5219263","0.5209234","0.5204689","0.5203593","0.5183008","0.51809096","0.5176393","0.51726544","0.51713914","0.51650935","0.5157402","0.5150467","0.51451945","0.51291466"],"string":"[\n \"0.6460845\",\n \"0.6460845\",\n \"0.6460829\",\n \"0.6281568\",\n \"0.62301815\",\n \"0.6133531\",\n \"0.6118104\",\n \"0.6079851\",\n \"0.6027266\",\n \"0.6002802\",\n \"0.5884031\",\n \"0.5878032\",\n \"0.5852781\",\n \"0.5839785\",\n \"0.5818881\",\n \"0.5815626\",\n \"0.5788101\",\n \"0.57821906\",\n \"0.57686496\",\n \"0.5767464\",\n \"0.57662016\",\n \"0.57374066\",\n \"0.570181\",\n \"0.56938726\",\n \"0.5693457\",\n \"0.5682508\",\n \"0.56789666\",\n \"0.56755066\",\n \"0.56543946\",\n \"0.5651858\",\n \"0.5634284\",\n \"0.5609847\",\n \"0.5578894\",\n \"0.5570315\",\n \"0.5567585\",\n \"0.5564256\",\n \"0.556038\",\n \"0.5558323\",\n \"0.555567\",\n \"0.5553563\",\n \"0.55486023\",\n \"0.5540778\",\n \"0.5525631\",\n \"0.5522256\",\n \"0.5519523\",\n \"0.54857254\",\n \"0.54831356\",\n \"0.5462947\",\n \"0.54507065\",\n \"0.54506415\",\n \"0.5448494\",\n \"0.54459846\",\n \"0.5443149\",\n \"0.54350674\",\n \"0.54078525\",\n \"0.5397158\",\n \"0.5382301\",\n \"0.53730667\",\n \"0.5365979\",\n \"0.53615135\",\n \"0.53611565\",\n \"0.53492355\",\n \"0.53379345\",\n \"0.5332028\",\n \"0.5327576\",\n \"0.5326515\",\n \"0.5321841\",\n \"0.53201735\",\n \"0.531898\",\n \"0.5298283\",\n \"0.5284508\",\n \"0.5275238\",\n \"0.5274833\",\n \"0.5269755\",\n \"0.5262699\",\n \"0.5259318\",\n \"0.52589\",\n \"0.524938\",\n \"0.524938\",\n \"0.524938\",\n \"0.52478963\",\n \"0.5245168\",\n \"0.52442384\",\n \"0.52376133\",\n \"0.52260864\",\n \"0.52238667\",\n \"0.5219364\",\n \"0.5219263\",\n \"0.5209234\",\n \"0.5204689\",\n \"0.5203593\",\n \"0.5183008\",\n \"0.51809096\",\n \"0.5176393\",\n \"0.51726544\",\n \"0.51713914\",\n \"0.51650935\",\n \"0.5157402\",\n \"0.5150467\",\n \"0.51451945\",\n \"0.51291466\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20154,"cells":{"query":{"kind":"string","value":"scan a Fortran file for dependencies. Needs to be distinct from target to allow for recursion induced by `include` statements.er It makes a number of assumptions, including `use`, `module`, `submodule` name is not on a continuation line Regex `incre` works for `include \"foo.f90\"` and `include \"foo.f90\"` `usere` works for legacy and Fortran 2003 `use` statements `submodre` is for Fortran >= 2008 `submodule`"},"document":{"kind":"string","value":"def _scan_fortran_file_deps(src: Path, srcdir: Path, dirname: Path, tdeps, compiler) -> T.List[str]:\n\n incre = re.compile(FORTRAN_INCLUDE_PAT, re.IGNORECASE)\n usere = re.compile(FORTRAN_USE_PAT, re.IGNORECASE)\n submodre = re.compile(FORTRAN_SUBMOD_PAT, re.IGNORECASE)\n\n mod_files = []\n src = Path(src)\n with src.open(encoding='ascii', errors='ignore') as f:\n for line in f:\n # included files\n incmatch = incre.match(line)\n if incmatch is not None:\n incfile = src.parent / incmatch.group(1)\n # NOTE: src.parent is most general, in particular for CMake subproject with Fortran file\n # having an `include 'foo.f'` statement.\n if incfile.suffix.lower()[1:] in compiler.file_suffixes:\n mod_files.extend(_scan_fortran_file_deps(incfile, srcdir, dirname, tdeps, compiler))\n # modules\n usematch = usere.match(line)\n if usematch is not None:\n usename = usematch.group(1).lower()\n if usename == 'intrinsic': # this keeps the regex simpler\n continue\n if usename not in tdeps:\n # The module is not provided by any source file. This\n # is due to:\n # a) missing file/typo/etc\n # b) using a module provided by the compiler, such as\n # OpenMP\n # There's no easy way to tell which is which (that I\n # know of) so just ignore this and go on. Ideally we\n # would print a warning message to the user but this is\n # a common occurrence, which would lead to lots of\n # distracting noise.\n continue\n srcfile = srcdir / tdeps[usename].fname\n if not srcfile.is_file():\n if srcfile.name != src.name: # generated source file\n pass\n else: # subproject\n continue\n elif srcfile.samefile(src): # self-reference\n continue\n\n mod_name = compiler.module_name_to_filename(usename)\n mod_files.append(str(dirname / mod_name))\n else: # submodules\n submodmatch = submodre.match(line)\n if submodmatch is not None:\n parents = submodmatch.group(1).lower().split(':')\n assert len(parents) in {1, 2}, (\n 'submodule ancestry must be specified as'\n f' ancestor:parent but Meson found {parents}')\n\n ancestor_child = '_'.join(parents)\n if ancestor_child not in tdeps:\n raise MesonException(\"submodule {} relies on ancestor module {} that was not found.\".format(submodmatch.group(2).lower(), ancestor_child.split('_', maxsplit=1)[0]))\n submodsrcfile = srcdir / tdeps[ancestor_child].fname\n if not submodsrcfile.is_file():\n if submodsrcfile.name != src.name: # generated source file\n pass\n else: # subproject\n continue\n elif submodsrcfile.samefile(src): # self-reference\n continue\n mod_name = compiler.module_name_to_filename(ancestor_child)\n mod_files.append(str(dirname / mod_name))\n return mod_files"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def scan_fortran_module_outputs(self, target):\n if self.use_dyndeps_for_fortran():\n return\n compiler = None\n # TODO other compilers\n for lang, c in self.environment.coredata.compilers.host.items():\n if lang == 'fortran':\n compiler = c\n break\n if compiler is None:\n self.fortran_deps[target.get_basename()] = {}\n return\n\n modre = re.compile(FORTRAN_MODULE_PAT, re.IGNORECASE)\n submodre = re.compile(FORTRAN_SUBMOD_PAT, re.IGNORECASE)\n module_files = {}\n submodule_files = {}\n for s in target.get_sources():\n # FIXME, does not work for Fortran sources generated by\n # custom_target() and generator() as those are run after\n # the configuration (configure_file() is OK)\n if not compiler.can_compile(s):\n continue\n filename = s.absolute_path(self.environment.get_source_dir(),\n self.environment.get_build_dir())\n # Fortran keywords must be ASCII.\n with open(filename, encoding='ascii', errors='ignore') as f:\n for line in f:\n modmatch = modre.match(line)\n if modmatch is not None:\n modname = modmatch.group(1).lower()\n if modname in module_files:\n raise InvalidArguments(\n f'Namespace collision: module {modname} defined in '\n f'two files {module_files[modname]} and {s}.')\n module_files[modname] = s\n else:\n submodmatch = submodre.match(line)\n if submodmatch is not None:\n # '_' is arbitrarily used to distinguish submod from mod.\n parents = submodmatch.group(1).lower().split(':')\n submodname = parents[0] + '_' + submodmatch.group(2).lower()\n\n if submodname in submodule_files:\n raise InvalidArguments(\n f'Namespace collision: submodule {submodname} defined in '\n f'two files {submodule_files[submodname]} and {s}.')\n submodule_files[submodname] = s\n\n self.fortran_deps[target.get_basename()] = {**module_files, **submodule_files}","def used_mods(ffile):\n import re\n import codecs\n\n # Go through line by line,\n # remove comments and strings because the latter can include ';'.\n # Then split at at ';', if given.\n # The stripped line should start with 'use '.\n # After use should be the \"module_name\", ', intrinsic :: module_name', or\n # ', non_intrinsic :: module_name'. We allow also to use \":: module_name\"\n # After module name should only be ', only: ...' or ', a ==> b'\n olist = list()\n of = codecs.open(ffile, 'r', encoding='ascii', errors='ignore')\n for line in of:\n ll = line.rstrip().lower() # everything lower case\n ll = re.sub('!.*$', '', ll) # remove F90 comment\n ll = re.sub('^c.*$', '', ll) # remove F77 comments\n ll = re.sub('\".*?\"', '', ll) # remove \"string\"\n ll = re.sub(\"'.*?'\", '', ll) # remove 'string'\n # check if several commands are on one line\n if ';' in ll:\n lll = ll.split(';')\n else:\n lll = [ll]\n for il in lll:\n iil = il.strip()\n # line should start with 'use '\n if iil.startswith('use '):\n iil = iil[4:].strip() # remove 'use '\n # skip intrinsic modules\n if 'intrinsic' in iil:\n if 'non_intrinsic' in iil:\n iil = re.sub(', *non_intrinsic', '', iil)\n iil = iil.strip()\n else:\n continue # skip to next in lll\n if iil.startswith('::'):\n iil = iil[2:].strip() # remove ':: '\n # remove after ',' if rename-list or only-list\n iil = re.sub(',.*$', '', iil)\n olist.append(iil.strip())\n of.close()\n\n return olist","def parse_deps():\n Files = []\n Dependencies = []\n TimeBins = ['recover_parameters', 'startup', 'wragh', 'paramcheck',\n 'preregridinitial', 'postregridinitial', 'basegrid', \n 'initial', 'postinitial', 'postrestrictinitial', \n 'postpostinitial', 'recover_variables', \n 'post_recover_variables', 'cpinitial', 'checkpoint', \n 'preregrid', 'postregrid', 'prestep', 'evol', 'postrestrict', \n 'poststep', 'analysis', 'terminate', 'shutdown']\n\n implement_re = re.compile('implements:\\s*(\\w+)', re.I)\n inherit_re = re.compile('inherits:\\s*(.+)', re.I)\n provides_function_re = re.compile('PROVIDES\\s+FUNCTION\\s+(\\w+)', re.I)\n uses_function_re = re.compile('USES\\s+FUNCTION\\s+(\\w+)', re.I)\n requires_function_re = re.compile('REQUIRES\\s+FUNCTION\\s+(\\w+)', re.I)\n shares_re = re.compile('shares:\\s*(\\w+)', re.I)\n requires_thorn_re = re.compile('REQUIRES\\s+(?!FUNCTION\\s*)(\\w+)', re.I)\n schedules_function_re = re.compile('schedule\\s+(?:group\\s+)?(\\w+)\\s+(?:in|at)\\s+(\\w+)', re.I)\n\n # find all interface.ccl and param.ccl files in cwd\n Cactus_Path = os.path.expanduser('~/Cactus/')\n for dirpath, dirnames, filenames in os.walk(Cactus_Path + 'arrangements', followlinks=True):\n for file in filenames:\n if file == 'interface.ccl':\n Files.append(os.path.join(dirpath, file))\n\n for file in Files:\n # first parse interface.ccl\n try:\n fptr = open(file, 'r')\n except IOError:\n print(\"Could not open %s\" % file) \n\n lines = fptr.readlines()\n\n try:\n fptr.close()\n except IOError:\n print(\"Could not close %s\" % file) \n\n # then parse param.ccl\n file = re.sub('interface.ccl', 'param.ccl', file)\n\n try:\n fptr = open(file, 'r')\n except IOError:\n print(\"Could not open %s\" % file) \n\n lines += fptr.readlines()\n\n try:\n fptr.close()\n except IOError:\n print(\"Could not close %s\" % file) \n\n # then configuration.ccl\n file = re.sub('param.ccl', 'configuration.ccl', file)\n\n try:\n fptr = open(file, 'r')\n lines += fptr.readlines()\n fptr.close()\n except IOError:\n pass\n\n # then schedule.ccl\n file = re.sub('configuration.ccl', 'schedule.ccl', file)\n\n try:\n fptr = open(file, 'r')\n lines += fptr.readlines()\n fptr.close()\n except IOError:\n pass\n\n # get the thorn dir and its parent\n thornname = os.path.basename(os.path.dirname(file))\n parentdir = os.path.basename(os.path.dirname(os.path.dirname(file)))\n thornname = os.path.join(parentdir, thornname)\n file_dict = {'name' : thornname.lower()}\n for line in lines:\n line = line.strip()\n m = re.match(implement_re, line)\n if m:\n file_dict['implements'] = m.group(1).lower()\n\n m = re.match(inherit_re, line)\n if m:\n inheritance = re.split('\\W+', m.group(1).lower())\n file_dict['inherits'] = inheritance\n\n m = re.match(provides_function_re, line)\n if m:\n try:\n file_dict['provides_function'].append(m.group(1).lower())\n except KeyError:\n file_dict['provides_function'] = [m.group(1).lower()]\n\n m = re.match(uses_function_re, line)\n if m:\n try:\n file_dict['uses_function'].append(m.group(1).lower())\n except KeyError:\n file_dict['uses_function'] = [m.group(1).lower()]\n\n m = re.match(requires_function_re, line)\n if m:\n try:\n file_dict['requires_function'].append(m.group(1).lower())\n except KeyError:\n file_dict['requires_function'] = [m.group(1).lower()]\n\n m = re.match(requires_thorn_re, line)\n if m:\n requires = re.split('\\W+', m.group(1).lower())\n # sometimes we have 'REQUIRES THORNS' instead of 'REQUIRES'\n if requires[0].lower() == 'thorns':\n del requires[0]\n file_dict['requires_thorn'] = requires\n\n m = re.match(shares_re, line)\n if m:\n try:\n file_dict['shares'].append(m.group(1).lower())\n except KeyError:\n file_dict['shares'] = [m.group(1).lower()]\n\n m = re.match(schedules_function_re, line)\n if m:\n bin, func = m.group(2).lower(), m.group(1).lower()\n if bin in TimeBins:\n bin = 'cctk_' + bin\n func_dict = {bin : func}\n try:\n file_dict['schedules_function'].append(func_dict)\n except KeyError:\n file_dict['schedules_function'] = [func_dict]\n\n\n Dependencies.append(file_dict)\n\n return Dependencies","def parse_deps(self, infile, classpath_indexer):\r\n raise NotImplementedError()","def get_fortran_deps(self, compiler: FortranCompiler, src: Path, target) -> T.List[str]:\n if self.use_dyndeps_for_fortran():\n return []\n\n dirname = Path(self.get_target_private_dir(target))\n tdeps = self.fortran_deps[target.get_basename()]\n srcdir = Path(self.source_dir)\n\n mod_files = _scan_fortran_file_deps(src, srcdir, dirname, tdeps, compiler)\n return mod_files","def _parseDependDotMake( targetBuildDir, platformBuildDir ):\n Any.requireIsTextNonEmpty( targetBuildDir )\n Any.requireIsTextNonEmpty( platformBuildDir )\n\n dependDotMakePath = os.path.join( targetBuildDir, 'depend.make' )\n\n lines = FastScript.getFileContent( dependDotMakePath, splitLines=True )\n result = collections.defaultdict( set )\n\n languageNormalizationMap = {\n '.c' : 'c',\n '.C' : 'c++',\n '.CC' : 'c++',\n '.CPP': 'c++',\n '.CXX': 'c++',\n '.cc' : 'c++',\n '.cpp': 'c++',\n '.cxx': 'c++',\n }\n\n for l in lines:\n # skip comments and empty lines\n if Any.isTextNonEmpty( l ) and not l.startswith( '#' ):\n # lines are in the format\n # /path/to/obj/file.{c,cpp,cc,cxx}.o: /path/to/dependencyfile.{c,cpp,cc,cxx,h,hpp,hxx,hh}\n objFile, depFile = l.split( ':' )\n srcFile, objExt = os.path.splitext( objFile.strip( ) )\n srcName, srcExt = os.path.splitext( srcFile )\n depFile = depFile.strip( )\n _, depFileExt = os.path.splitext( depFile )\n language = languageNormalizationMap[ srcExt ]\n\n if depFileExt.lower( ) in ('.h', '.hxx', '.hpp', '.hh'):\n if not os.path.isabs( depFile ):\n relPath = os.path.join( platformBuildDir, depFile )\n absPath = os.path.abspath( relPath )\n else:\n absPath = depFile\n result[ absPath ].add( language )\n\n\n return result","def rl_file_deps(file_deps, launch_file, verbose=False):\n parse_launch(launch_file, file_deps, verbose)","def main(path):\n try:\n print(\"Finding imports in '\" + path + \"':----------------------------------------------------------------------\")\n\n file = open(path)\n contents = file.read()\n wordArray = re.split(\" |\\n\", contents)\n\n currentList = list()\n nextPaths = list()\n skipWord = -1\n\n for wordNumb in range(len(wordArray)):\n word = wordArray[wordNumb]\n\n if wordNumb == skipWord:\n continue\n\n elif word == \"from\":\n item = wordArray[wordNumb + 1]\n if 'vespa.' in item:\n currentList.append(item)\n skipWord = wordNumb + 2\n\n elif word == \"import\":\n item = wordArray[wordNumb + 1]\n if 'vespa.' in item:\n currentList.append(item)\n\n currentList = set(currentList)\n for i in currentList:\n print(i)\n\n # print(\"Found imports in '\" + path + \"'\")\n # print(\"Finding paths for imports in '\" + path + \"':\")\n\n currentList2 = currentList.copy()\n currentList = list()\n\n for i in currentList2:\n if i in dependenciesNames:\n # print(i, \"already found\")\n pass\n\n else:\n dependenciesNames.append(i)\n\n try:\n fileInfo = importlib.machinery.PathFinder().find_spec(i)\n if fileInfo is None:\n fileInfo = importlib.util.find_spec(i)\n if fileInfo is None:\n origin = 'None'\n else:\n origin = fileInfo.origin\n else:\n origin = fileInfo.origin\n\n print(origin)\n dependenciesPaths.append(origin)\n currentList.append(origin)\n\n except AttributeError as e:\n print(\"Hit Exception: AttributeError\")\n print(e)\n print(i)\n print(importlib.machinery.PathFinder().find_spec(i))\n # print(red, \"Odd noneType import called \", i, \" in path \", path, end, sep='')\n\n\n# print(\"Found paths for imports in '\" + path + \"'\")\n\n\n for fileInfo in currentList:\n main(fileInfo)\n\n except Exception as e:\n print(e)","def scan_docs():\n\n\n def scan_file(fn):\n f = open(fn)\n\n for l in f:\n m = re.search(r\"\\.\\. (\\w+):: ([.\\w+]+)\", l)\n\n if not m:\n continue\n\n name_kind[m.group(2)] = m.group(1)\n\n for i in os.listdir(\"source\"):\n if i.endswith(\".rst\"):\n scan_file(os.path.join(\"source\", i))\n\n for i in os.listdir(\"source/inc\"):\n scan_file(os.path.join(\"source\", \"inc\", i))","def read_deps():\n with open(\"./dependencies.txt\", 'r') as deps:\n return [d for d in re.split(r'\\s', ''.join(deps)) if d]","def find_define_file_uses(self):\n # Executing git grep is substantially faster than using the define_re\n # directly on the contents of the file in Python.\n for define_file in self.get_checked_define_files():\n excluded_files = set([define_file])\n excluded_files.update(define_file.get_included_files(recursive=True))\n all_defines = define_file.get_declared_defines()\n args = ['git', 'grep', '-zwIF']\n for define in all_defines:\n args.extend(['-e', define])\n args.extend(['--', '*.cpp', '*.c', '*.cu', '*.h', '*.cuh'])\n define_re = r'\\b(?:' + '|'.join(all_defines)+ r')\\b'\n output = subprocess.check_output(args, cwd=self._source_root).decode()\n for line in output.splitlines():\n (filename, text) = line.split('\\0')\n fileobj = self._files.get(filename)\n if fileobj is not None and fileobj not in excluded_files:\n defines = re.findall(define_re, text)\n fileobj.add_used_defines(define_file, defines)","def add_file_dependency(self, file_name=None):\n # self.logger.debug(\"add_file_dependency({0})\".format(file_name))\n\n if not isinstance(file_name, str):\n raise TypeError\n\n if not os.path.exists(file_name):\n raise FileNotFoundError(\n \"module_dependency: file({}) doesn't exist.\".format(file_name))\n\n if not os.path.isfile(file_name):\n raise FileNotFoundError(\n \"module_dependency: file({}) doesn't exist.\".format(file_name))\n\n value = os.path.splitext(file_name)\n # should be like ('network\\\\tcp_echo\\\\tcp_echo', '.py') or\n # ('network\\\\tcp_echo', '')\n # self.logger.debug(\"value({})\".format(value))\n if value[1] != \".py\":\n # self.logger.debug(\n # \"module_dependency: file({}) is not PYTHON (.py)normal file.\")\n return None\n\n # at this point, the file should be a .PY file at least\n file_han = open(file_name)\n for line in file_han:\n offset = line.find(\"import\")\n if offset >= 0:\n # then we found a line\n tokens = line.split()\n\n if len(tokens) >= 2 and tokens[0] == \"import\":\n # then like \"import os.path\" or \"import os, sys, socket\"\n\n if tokens[1][-1] != \",\":\n # then is like \"import os.path\"\n self.logger.debug(\"add_file_dep:{}\".format(tokens[1]))\n self.add_if_new(tokens[1])\n\n else: # like \"import os, sys, socket\"\n for name in tokens[1:]:\n self.logger.debug(\"token({})\".format(name))\n if name[-1] == ',':\n value = name[:-1]\n else:\n value = name\n self.add_if_new(value)\n\n elif len(tokens) >= 4 and tokens[0] == \"from\" and \\\n tokens[2] == \"import\":\n # then is like \"from cp_lib.cp_self.logger import\n # get_recommended_logger\"\n self.add_if_new(tokens[1])\n\n file_han.close()\n\n # self.logger.debug(\"module_dependency: {}\".format(self.dep_list))\n return self.dep_list","def scan_files(self, only_files=None, keep_contents=False):\n if only_files:\n filelist = only_files\n else:\n filelist = self._files.values()\n define_files = list(self.get_checked_define_files())\n for define_file in list(define_files):\n if isinstance(define_file, GeneratedFile) and \\\n define_file.get_generator_source() is not None:\n define_files.append(define_file.get_generator_source())\n for fileobj in filelist:\n if not fileobj.is_external():\n detect_defines = fileobj in define_files\n fileobj.scan_contents(self, keep_contents, detect_defines)\n module = fileobj.get_module()\n if module:\n for includedfile in fileobj.get_includes():\n otherfile = includedfile.get_file()\n if otherfile:\n othermodule = otherfile.get_module()\n if othermodule and othermodule != module:\n module.add_dependency(othermodule, includedfile)","def find_with_deps(self, package_names):","def scan(\n cli_call_name: str, module: str, package: Optional[str], verbose: bool, help: Optional[str]\n) -> CommandTrie:\n root_module = importlib.import_module(module, package=package)\n root_path = root_module.__file__\n\n if verbose:\n print(\"Scanning module {} starting at file path: {}\".format(module, root_path))\n\n # Format the module name correctly if this is a relative import we're starting with\n target_module = module\n if _is_relative(target_module):\n if package is None:\n raise CommandError(\"Package was not specified but the module is relative.\")\n\n target_module = package\n\n # Search path changes if the __file__ entry is a python init file and not a directory\n search_path = root_path\n if search_path.endswith(_PYTHON_MODULE_INIT_FILE):\n search_path = os.path.dirname(root_path)\n\n # First identify all submodules\n submodule_names = list()\n\n # If our search path is not a directory, move on\n if os.path.isdir(search_path):\n for filename in os.listdir(search_path):\n if filename in _IGNORE_LIST:\n continue\n\n abs_path = os.path.join(search_path, filename)\n init_path = os.path.join(abs_path, _PYTHON_MODULE_INIT_FILE)\n\n module_name = \"\"\n if os.path.isdir(abs_path) and os.path.exists(init_path):\n # Figure out if we're dealing with a directory that has the init file\n module_name = \".\".join((target_module, filename))\n elif _is_python_src_file(filename):\n # Is it a python source file that's stand-alone?\n file_module_name = os.path.splitext(filename)[0]\n module_name = \".\".join((target_module, file_module_name))\n else:\n # I don't like this continue but avoiding the print statement twice is a nice consequence\n continue\n\n if verbose:\n print(\"Adding module {} to the scan list.\".format(module_name))\n\n # Add the module to our scan and import list\n submodule_names.append(module_name)\n\n # Load the modules\n submodules = [importlib.import_module(n) for n in submodule_names]\n\n # Add the root module since that's part of the scan\n submodules.append(root_module)\n\n # Load and scan the submodules for command components\n command_components = list()\n for submodule in submodules:\n for component_name in dir(submodule):\n component = getattr(submodule, component_name)\n if isinstance(component, CommandWrapper):\n if verbose:\n print(\"Found command component: {}\".format(component))\n\n command_components.append(component)\n\n # Build our command trie with collected components and perform rudimentary\n # dependency resolution for command paths\n command_trie = CommandTrie(cli_call_name, help=help)\n while len(command_components) > 0:\n delete_list = list()\n for idx in range(0, len(command_components)):\n command = command_components[idx]\n\n if command_trie.insert(command) is True:\n if verbose:\n print(\"Inserted {}\".format(command))\n\n delete_list.append(idx)\n break\n\n if len(delete_list) == 0:\n raise CommandDependencyError(\"Dependency resolution error!\")\n\n for idx in reversed(sorted(delete_list)):\n command_components.pop(idx)\n\n return command_trie","def PrepareCompile(file):\n global oilcc_I,oilcc_o,oilcc_S,oilcc_target\n fp = open(file,'r')\n # some flags\n item = ''; #one item is minimum object such as TASK,ALARM ...\n barcenum = 0;\n flag = False; #has \" { \" encountered or not\n start = False #has match an obj start or not\n for line in fp.readlines():\n #firstly, filter out the comment on this line\n el = DropComment(line);\n if(start == False):\n #{\n item = ''; \n barcenum = 0;\n flag = False;\n if(IsIt('osekObj',el)):\n start = True;\n item += el;\n if(el.count('{') > 0): #so at comment should not include '{}'\n flag = True;\n barcenum += el.count('{');\n if(el.count('}') > 0):\n barcenum -= el.count('}');\n if((flag == True) and (barcenum == 0)): #in one line\n #filter out the multi-line comment\n item = DropComment(item)\n oilcc_texts.append(item);\n start = False\n else: # special process for include\n inc = GetIt('include',el)\n if(inc != None): #include file\n flag_inc = False\n for I in oilcc_I:\n finc = I + '/' + inc[0]\n if(os.path.exists(finc)):\n print 'INFO:parse include file <%s> in the path <%s>'%(inc[0],I)\n PrepareCompile(finc);\n flag_inc = True;\n if(flag_inc == False):\n print 'ERROR:cann\\'t find out the file %s!'%(inc[0])\n sys.exit(-1)\n #}\n else:\n #{\n if(el.count('{') > 0): #so at comment should not include '{}'\n flag = True;\n barcenum += el.count('{');\n if(el.count('}') > 0):\n barcenum -= el.count('}');\n item += el;\n if((flag == True) and (barcenum == 0)):\n #filter out the multi-line comment\n item = DropComment(item)\n oilcc_texts.append(item);\n start = False\n #}\n fp.close()","def _get_include_files(self):\n for dirpath, dirnames, filenames in os.walk(self.IncludesDirectory):\n for f in filenames:\n rel_name = path.join(dirpath, f)\n if f.endswith('.pyx'):\n yield (rel_name, 'PyRex')\n elif f.endswith('.h'):\n yield (rel_name, 'Header')\n else:\n pass","def _resolve_required_macros(file_content):\n call_commands = \"\"\n for line in file_content.split(\"\\n\"):\n match = re.search(\"^!@require\\s+([^\\s]+).*$\", line)\n if match is not None:\n required_macros = _add_macro_lib_ending(match.group(1))\n required_macros_file = abspath(join(LIB, required_macros))\n call_commands += _resolve_required_macros(_read_input_file(required_macros_file))\n call_commands += \"call, file = \\\"\" + required_macros_file + \"\\\";\\n\"\n return call_commands","def Load():\n global items, libraries, _line_number, _groups_to_be_defined\n deps_file = open(\"dependencies.txt\")\n try:\n line = None\n current_type = None\n while True:\n while not line: line = _RemoveComment(deps_file.next())\n\n if line.startswith(\"library: \"):\n current_type = \"library\"\n name = line[9:].lstrip()\n _CheckLibraryName(name)\n if name in items:\n sys.exit(\"Error:%d: library definition using duplicate name %s\" % (_line_number, name))\n libraries.add(name)\n item = items[name] = {\"type\": \"library\", \"name\": name}\n line = _ReadFiles(deps_file, item, name)\n elif line.startswith(\"group: \"):\n current_type = \"group\"\n name = line[7:].lstrip()\n _CheckGroupName(name)\n if name not in items:\n sys.exit(\"Error:%d: group %s defined before mentioned as a dependency\" %\n (_line_number, name))\n if name not in _groups_to_be_defined:\n sys.exit(\"Error:%d: group definition using duplicate name %s\" % (_line_number, name))\n _groups_to_be_defined.remove(name)\n item = items[name]\n item[\"name\"] = name\n library_name = item.get(\"library\")\n if library_name:\n line = _ReadFiles(deps_file, item, library_name)\n else:\n line = _ReadSystemSymbols(deps_file, item)\n elif line == \" deps\":\n if current_type == \"library\":\n line = _ReadDeps(deps_file, items[name], name)\n elif current_type == \"group\":\n item = items[name]\n line = _ReadDeps(deps_file, item, item.get(\"library\"))\n elif current_type == \"system_symbols\":\n item = items[current_type]\n line = _ReadDeps(deps_file, item, None)\n else:\n sys.exit(\"Error:%d: deps before any library or group\" % _line_number)\n elif line == \"system_symbols:\":\n current_type = \"system_symbols\"\n if current_type in items:\n sys.exit(\"Error:%d: duplicate entry for system_symbols\" % _line_number)\n item = items[current_type] = {\"type\": current_type, \"name\": current_type}\n line = _ReadSystemSymbols(deps_file, item)\n else:\n sys.exit(\"Syntax error:%d: %s\" % (_line_number, line))\n except StopIteration:\n pass\n if _groups_to_be_defined:\n sys.exit(\"Error: some groups mentioned in dependencies are undefined: %s\" % _groups_to_be_defined)","def read_dependencies(filename):\n\n dependencies = []\n with open(filename) as f:\n for line in f.readlines():\n if not line or line.startswith('#'):\n continue\n dependencies.append(line.strip())\n return dependencies","def get_docs( mysource , basename ):\n import parser\n ast = parser.suite(mysource)\n return ModuleInfo(ast.totuple(1), basename)","def pre_process(in_path):\n in_string = open(in_path, 'r').read()\n multi_line = '/\\\\*[^*]*\\\\*+(?:[^/*][^*]*\\\\*+)*/'\n\n # header\n description = re.search(multi_line, in_string).group(0)\n unit = re.search('\\\\n\\\\s*// unit .*', in_string).group(0)\n imports = re.findall('\\\\n\\\\s*// import .*', in_string)\n import_string = ''\n for i in imports:\n import_string += resolve_import(i.strip()[10:], in_path.parent)\n\n use_string = ''\n uses = re.findall('\\\\n\\\\s*// uses .*', in_string)\n for u in uses:\n use_string += 'uses ' + u.strip()[8:] + ';\\n'\n if use_string != '':\n use_string = '\\n\\n' + use_string\n\n header = '{' + description[2:-2] + '}\\n\\nunit ' + unit.strip()[8:] + ';' + use_string + '\\n\\n'\n\n # main part\n in_string_list, delphi_string_list = split(import_string + '\\n\\n' + in_string)\n\n return header, in_string_list, delphi_string_list","def test_scan_and_find_dependencies_golang():\n manifests = [{\n \"filename\": \"golist.json\",\n \"filepath\": \"/bin/local\",\n \"content\": open(str(Path(__file__).parent / \"data/manifests/gograph.txt\")).read()\n }]\n res = DependencyFinder().scan_and_find_dependencies(\"golang\", manifests, \"true\")\n assert \"result\" in res\n assert res['result'][0]['details'][0]['_resolved'][0]['package'] == \\\n \"github.com/go-logr/logr\"","def main():\n if len(sys.argv) == 1:\n print(\"No dependencies file to validate!\")\n return\n dependencies_file = sys.argv[1]\n try:\n dependencies = json.loads(open(dependencies_file, 'r').read())\n except json.decoder.JSONDecodeError:\n print(\"Invalid dependency file syntax! Make sure you don't have any commas at the end of your last dependency.\")\n return\n for dependency in dependencies:\n if 'target_path' in dependency and 'repository' in dependency:\n print(\"Validated {}\".format(dependency['target_path']))\n suggest_edits(dependency)\n elif 'target_path' not in dependency and 'repository' in dependency:\n print(\"Define target_path for dependency {}\".format(dependency['repository']))\n elif 'repository' not in dependency and 'target_path' in dependency:\n print(\"Define repository for dependency {}\".format(dependency['target_path']))\n else:\n print(\"Invalid format, missing repository and target_path for dependency {}\".format(dependencies.index(dependency)))","def _scan_bytecode(\n self, module, module_code_object, is_scanning_imports):\n level = None\n fromlist = None\n\n # 'deque' is a list-like container with fast appends, pops on\n # either end, and automatically discarding elements too much.\n prev_insts = deque(maxlen=2)\n for inst in util.iterate_instructions(module_code_object):\n if not inst:\n continue\n # If this is an import statement originating from this module,\n # parse this import.\n #\n # Note that the related \"IMPORT_FROM\" opcode need *NOT* be parsed.\n # \"IMPORT_NAME\" suffices. For further details, see\n # http://probablyprogramming.com/2008/04/14/python-import_name\n if inst.opname == 'IMPORT_NAME':\n # If this method is ignoring import statements, skip to the\n # next opcode.\n if not is_scanning_imports:\n continue\n\n assert prev_insts[-2].opname == 'LOAD_CONST'\n assert prev_insts[-1].opname == 'LOAD_CONST'\n\n # Python >=2.5: LOAD_CONST flags, LOAD_CONST names, IMPORT_NAME name\n level = prev_insts[-2].argval\n fromlist = prev_insts[-1].argval\n\n assert fromlist is None or type(fromlist) is tuple\n target_module_partname = inst.argval\n\n #FIXME: The exact same logic appears in _collect_import(),\n #which isn't particularly helpful. Instead, defer this logic\n #until later by:\n #\n #* Refactor the \"_deferred_imports\" list to contain 2-tuples\n # \"(_safe_import_hook_args, _safe_import_hook_kwargs)\" rather\n # than 3-tuples \"(have_star, _safe_import_hook_args,\n # _safe_import_hook_kwargs)\".\n #* Stop prepending these tuples by a \"have_star\" boolean both\n # here, in _collect_import(), and in _process_imports().\n #* Shift the logic below to _process_imports().\n #* Remove the same logic from _collect_import().\n have_star = False\n if fromlist is not None:\n fromlist = uniq(fromlist)\n if '*' in fromlist:\n fromlist.remove('*')\n have_star = True\n\n # Record this import as originating from this module for\n # subsequent handling by the _process_imports() method.\n module._deferred_imports.append((\n have_star,\n (target_module_partname, module, fromlist, level),\n {}\n ))\n\n elif inst.opname in ('STORE_NAME', 'STORE_GLOBAL'):\n # If this is the declaration of a global attribute (e.g.,\n # class, variable) in this module, store this declaration for\n # subsequent lookup. See method docstring for further details.\n #\n # Global attributes are usually irrelevant to import parsing, but\n # remain the only means of distinguishing erroneous non-ignorable\n # attempts to import non-existent submodules of a package from\n # successful ignorable attempts to import existing global\n # attributes of a package's \"__init__\" submodule (e.g., the \"bar\"\n # in \"from foo import bar\", which is either a non-ignorable\n # submodule of \"foo\" or an ignorable global attribute of\n # \"foo.__init__\").\n name = inst.argval\n module.add_global_attr(name)\n\n elif inst.opname in ('DELETE_NAME', 'DELETE_GLOBAL'):\n # If this is the undeclaration of a previously declared global\n # attribute (e.g., class, variable) in this module, remove that\n # declaration to prevent subsequent lookup. See method docstring\n # for further details.\n name = inst.argval\n module.remove_global_attr_if_found(name)\n\n prev_insts.append(inst)","def required_files(self, args):\n args_set = set(args)\n edge_list = self.__transform_pre(self.__include_deps_supply.get_file_include_deps())\n targets = chain((target for (source, target) in edge_list if source in args_set), args_set)\n return self.__transform_post(targets)","def get_deps(cat, pkg, ns, rpkgs):\n with (settings.RAINBOARD_RPKG / cat / pkg / \"Makefile\").open() as file_handle:\n cont = file_handle.read()\n deps = [\n d_pkg\n for d_cat, d_pkg, _ in rpkgs\n if f\"\\ninclude ../../{d_cat}/{d_pkg}/depend.mk\\n\" in cont\n ]\n if pkg.startswith(\"py-\") and (cat, pkg[3:], ns) in rpkgs:\n deps.append(pkg[3:])\n deps_cache[pkg] = sorted(set(deps))\n return deps_cache[pkg]","def gather_required_files(filename):\n # open the file, while ignoring encoding errors (usually comments)\n encoding = open_guess_encoding(filename)\n with open(filename, encoding=encoding, errors='surrogateescape') as fp:\n config = MugenParser()\n config.read_string(fp.read())\n\n # go through each section and store any options that look like filenames\n required = set()\n for section in config.sections():\n section = config[section]\n options = set(find_asset(normpath(v)) for k, v in section.items()\n if filename_regex.match(v))\n required.update(options)\n\n # check other def files, then search them and add the results\n root = dirname(filename)\n for child_file in required.copy():\n name, ext = os.path.splitext(child_file)\n if ext.lower() == '.def':\n path = join(root, child_file)\n required.update(gather_required_files(path))\n\n # TODO: this is not implemented\n # mugen does checking against many paths, so we need\n # to emulate that the if we want to check for missing files\n # finally, go through the potential files and verify they exist\n # for child_file in required.copy():\n # path = join(root, child_file)\n # if not os.path.exists(path):\n # required.remove(child_file)\n\n return required","def generate_dependencies(data, mib_name):\r\n if mib_name not in mib_dependency_map:\r\n mib_dependency_map[mib_name] = []\r\n imports_section_search = re.search('IMPORTS(?P<imports_section>.*?);', data, re.DOTALL)\r\n if imports_section_search:\r\n imports_section = imports_section_search.group('imports_section')\r\n for dependency in re.finditer('FROM (?P<mib_name>[\\w-]+)', imports_section):\r\n dependency_name = dependency.group('mib_name')\r\n if dependency_name not in mib_dependency_map:\r\n mib_dependency_map[dependency_name] = []\r\n mib_dependency_map[mib_name].append(dependency_name)","def find_extra_include(file_name):\r\n extra_includes = []\r\n with open(file_name) as f:\r\n for m in re.finditer(regex.extra_include, f.read()):\r\n extra_includes.append(m.groups(1))\r\n return extra_includes","def define_regex(module_names=modules, doc_types=types, exts=exts):\n letters = ''\n module_codes = ''\n file_exts = ''\n # Populate code letter String\n for letter in doc_types:\n letters += letter\n # Populate extension string\n for ext in exts:\n if ext != exts[-1]:\n file_exts += f\"{ext}|\"\n else:\n file_exts += ext\n # Populate modules string\n for module in modules:\n if module != modules[-1]:\n module_codes += f\"{module}|\"\n else:\n module_codes += module\n regex = r\"(\" + module_codes + \"){1}[\" + letters + \"]{1}\\_[^.]*\\.(\" + file_exts + \")\" \n return regex","def _verify_include_files_used(self, file_uses, included_files):\n for include_file, use in file_uses.items():\n if not use & USES_DECLARATION:\n node, module = included_files[include_file]\n if module.ast_list is not None:\n msg = \"'{}' does not need to be #included\".format(\n node.filename)\n if use & USES_REFERENCE:\n msg += '; use a forward declaration instead'\n self._add_warning(msg, node)","def find_dependencies(root):\n \n symbol_table = create_symbol_table(root)\n\n names = []\n #Set the depth of the root node\n set_depth(root, 0)\n #Stack of nodes to visit\n stack = Stack(root)\n \n #List of (src, dest) of dependencies\n dependency_table = DTable(symbol_table=symbol_table)\n\n for node, children, ntype in stack:\n \n stack.check_and_push_scope()\n\n #A Name is being loaded, therefore \n if ntype == \"Name\" and is_load(children):\n \"\"\"\n \"\"\"\n dependency_table.append( (stack.scopes, node))\n \n elif ntype == \"Assign\":\n #TODO need to add assignments and then revoke them\n #for child in children:\n #print children\n pass\n\n \n elif ntype == \"Attribute\":\n #TODO: attribute chains can be arbitrarily long\n #dep_dest = \"{}.{}\".format(node.value.id, node.attr)\n #print \"{} => {}\".format(scopes_to_str(scopes), dep_dest)\n\n #TODO: Can't just do dependency_table.append( (scopes, node))\n #since the unique_id function won't match the create the dep string like \n #{node.value.id}.{node.attr}.\n #Either generalize unique_id or something else.\n \n #Don't add children\n continue\n \n set_lineno(node, children)\n #Add children to stack\n #This musn't always be performed\n for child in children[::-1]:\n set_depth(child, node.depth + 1)\n stack.append(child)\n\n print \"dependency table is \"\n print dependency_table","def get_dependencies(path):\n dependencies_path = os.path.join(path, \"dependencies.txt\")\n dependencies_pattern = r\"([a-z]+(?:[_-][a-z]+)*)(.=)+(([1-9][0-9]*!)?(0|[1-9][0-9]*)(\\.(0|[1-9][0-9]*))*((a|b|rc)(0|[1-9][0-9]*))?(\\.post(0|[1-9][0-9]*))?(\\.dev(0|[1-9][0-9]*))?)\"\n \"\"\"\n Example:\n input: iobeam==0.7.15\n mrb-hw-info==0.0.25\n mrbeam-ledstrips==0.2.2-alpha.2\n output: [[iobeam][==][0.7.15]]\n [[mrb-hw-info][==][0.0.25]]\n [[mrbeam-ledstrips][==][0.2.2-alpha.2]]\n \"\"\"\n try:\n with open(dependencies_path, \"r\") as f:\n dependencies_content = f.read()\n dependencies = re.findall(dependencies_pattern, dependencies_content)\n dependencies = [{\"name\": dep[0], \"version\": dep[2]} for dep in dependencies]\n except IOError:\n raise RuntimeError(\"Could not load dependencies\")\n return dependencies","def extract_deps(self, srcinfo):\n packages = {}\n pkgname = \"\"\n\n for i in srcinfo.split(\"\\n\"):\n if not i:\n continue\n if i[0] == \"#\":\n continue\n option = i.strip()\n key, value = option.split(\" = \")\n if key == \"pkgbase\":\n pkgname = value\n packages[pkgname] = []\n if key == \"makedepends\":\n packages[pkgname].append(value)\n # if key == \"depends\":\n # packages[pkgname].append(value)\n return packages","def includeme(root):\n configure.scan(\"backend.services\")\n configure.scan(\"backend.content\")\n configure.scan(\"backend.install\")","def find_modules(x):\n return Path(x).rglob('*.py')","def __get_compile_cache_dep_files(file_path, compile_cache_dep_files, pkg):\n with open(file_path) as fh:\n root = ast.parse(fh.read(), file_path)\n for node in ast.iter_child_nodes(root):\n module_name = \"\"\n if isinstance(node, ast.ImportFrom):\n if node.module is not None:\n module_name = node.module\n if node.level == 1:\n module_name = \".\" + module_name\n elif not isinstance(node, ast.Import):\n continue\n # Do not care the files in mindspore package\n if module_name.startswith(\"mindspore\"):\n continue\n\n for n in node.names:\n if n.name.startswith(\"mindspore\"):\n continue\n if module_name == \"\":\n whole_module = n.name\n else:\n whole_module = module_name\n if n.name is not None:\n whole_module += \".\" + n.name\n try:\n module_spec = importlib.util.find_spec(whole_module, pkg)\n except (ModuleNotFoundError, ValueError):\n whole_module = whole_module[0:whole_module.rfind('.')]\n module_spec = importlib.util.find_spec(whole_module, pkg)\n if module_spec is None:\n continue\n module = importlib.util.module_from_spec(module_spec)\n if hasattr(module, '__file__'):\n dep_file_path = module.__file__\n else:\n continue\n # Exclude the installed modules.\n if not _in_sys_path(dep_file_path) and dep_file_path not in compile_cache_dep_files:\n logger.debug(f\"dependent file path: {dep_file_path}\")\n compile_cache_dep_files.append(dep_file_path)\n __get_compile_cache_dep_files(dep_file_path, compile_cache_dep_files, module.__package__)","def find_reference_files():\n for root, _, files in os.walk(\"./tests/references/\"):\n for basename in fnmatch.filter(files, \"*.tex\"):\n yield os.path.join(root, basename)","def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\n import re\n\n if not def_re :\n storage_class = br\"(static\\s+)?\"\n type_and_name = br\"int\\s+(?P<n>test_[_a-zA-Z0-9]*)\";\n args=br\"\\(.*\\)\";\n def_re = re.compile(b\"\\s*\" + storage_class +\n type_and_name + b\"\\s*\" +\n args );\n\n tests = set()\n with open(filename, \"rb\") as f:\n for line in f:\n m = def_re.match(line)\n if not m : continue\n cb(line, m)\n tests.add( m.group('n').strip().decode('utf-8') )\n return tests","def __compute_dependencies(self):\n prefix = \"github.com/DataDog/datadog-agent/\"\n base_path = os.getcwd()\n mod_parser_path = os.path.join(base_path, \"internal\", \"tools\", \"modparser\")\n\n if not os.path.isdir(mod_parser_path):\n raise Exception(f\"Cannot find go.mod parser in {mod_parser_path}\")\n\n try:\n output = subprocess.check_output(\n [\"go\", \"run\", \".\", \"-path\", os.path.join(base_path, self.path), \"-prefix\", prefix],\n cwd=mod_parser_path,\n ).decode(\"utf-8\")\n except subprocess.CalledProcessError as e:\n print(f\"Error while calling go.mod parser: {e.output}\")\n raise e\n\n # Remove github.com/DataDog/datadog-agent/ from each line\n return [line[len(prefix) :] for line in output.strip().splitlines()]","def getRefs(self):\n\n backend = self.backend\n refs = self.moduleRefs\n for ref in refs:\n refPure = ref.rsplit(\":\", 1)[0]\n if refPure in self.seen:\n continue\n\n parts = splitModRef(ref)\n if not parts:\n self.good = False\n continue\n\n parts[2] = prefixSlash(normpath(parts[2])) # the relative bit\n theBackend = (\n None if parts[-1] is None or parts[-1] == backend else parts[-1]\n )\n\n if not self.getModule(*parts[0:-1], backend=theBackend):\n self.good = False","def search(self, src, exclude_pattern = [\"**/*.pyc\"], include_pattern = [\"**/*.py\"]):\n src = os.path.abspath(src)\n \n _target = Path(src)\n _target._flavour.casefold = lambda x : x # basic windows path don't distinguish upper / lower case.\n allfiles = list(_target.glob(\"**/*\"))\n \n exclude = list()\n for _ex in exclude_pattern:\n exclude += _target.glob(_ex) \n \n include = list()\n for _in in include_pattern:\n include += _target.glob(_in) \n \n _target_path = set(allfiles) - set(exclude) | set(include)\n \n _target_dir_path = sorted(list(x for x in _target_path if x.is_dir() is True))\n _target_file_path = sorted(list(x for x in _target_path if x.is_file() is True))\n \n return _target_dir_path, _target_file_path","def checkAllFilesIncluded(self):\n # TODO: config objects: this import can go away\n from exhale.configs import unabridgedOrphanKinds\n\n # build path to unabridged api document that adds all toctree directives\n root = get_exhale_root(self)\n containmentFolder = self.getAbsContainmentFolder()\n unabridged_api_path = os.path.join(containmentFolder, \"unabridged_api.rst.include\")\n unabridged_orphan_path = os.path.join(containmentFolder, \"unabridged_orphan.rst\")\n\n # gather lines that match the indented part of the toctree\n #\n # .. toctree::\n # :maxdepth: {toctreeMaxDepth}\n #\n # some_node.file_name.rst\n #\n # so just lazily look for the leading three spaces and ending with .rst\n full_api_toctrees = []\n under_toctree_re = re.compile(r\"^ .+\\.rst$\")\n with open(unabridged_api_path) as unabridged_api:\n for line in unabridged_api:\n if under_toctree_re.match(line):\n full_api_toctrees.append(line.strip())\n\n orphan_toctrees = []\n if os.path.isfile(unabridged_orphan_path):\n with open(unabridged_orphan_path) as unabridged_orphan:\n for line in unabridged_orphan:\n if under_toctree_re.match(line):\n orphan_toctrees.append(line.strip())\n\n # Scan all nodes and make sure they were found in the toctrees above.\n doxygen_mainpage_was_used = False\n for node in root.all_nodes:\n if node.kind in {\"enumvalue\", \"group\"}:\n continue\n\n # When doxygen \\mainpage command is used, the .. doxygenpage:: index\n # is .. include::'ed in the root file document. Those checks come\n # after this loop.\n if node.kind == \"page\" and node.refid == \"indexpage\":\n doxygen_mainpage_was_used = True\n continue\n\n if node.kind in unabridgedOrphanKinds or \\\n (node.kind == \"class\" and \"struct\" in unabridgedOrphanKinds) or \\\n (node.kind == \"struct\" and \"class\" in unabridgedOrphanKinds):\n toctrees = orphan_toctrees\n doc = unabridged_orphan_path\n else:\n toctrees = full_api_toctrees\n doc = unabridged_api_path\n\n self.assertTrue(\n node.file_name in toctrees,\n \"Node refid=[{refid}] and basename=[{file_name}] not found in [{doc}]!\".format(\n refid=node.refid, file_name=node.file_name, doc=doc\n )\n )\n\n # Make sure every document expected to be .. include::'ed in the library root\n # has actually been included.\n full_root_file_path = root.full_root_file_path\n root_file_includes = []\n with open(full_root_file_path, \"r\") as full_root_f:\n for line in full_root_f:\n include_mark = \".. include::\"\n if line.startswith(include_mark):\n root_file_includes.append(line.split(include_mark)[-1].strip())\n\n index_include = False # page_index.rst comes from doxygen \\mainpage\n page_hierarchy_include = False # page_view_hierarchy.rst\n class_hierarchy_include = False # class_view_hierarchy.rst\n file_hierarchy_include = False # file_view_hierarchy.rst\n unabridged_api_include = True # unabridged_api.rst. Always included.\n orphan_api_include = False # unabridged_orphan.rst. Never included.\n for node in root.all_nodes:\n if node.kind == \"page\":\n if node.refid == \"indexpage\":\n index_include = True\n else:\n page_hierarchy_include = True\n elif node.kind in exhale.utils.CLASS_LIKE_KINDS:\n class_hierarchy_include = True\n elif node.kind in {\"dir\", \"file\"}:\n file_hierarchy_include = True\n\n self.assertTrue(\n doxygen_mainpage_was_used == index_include,\n \"Mismatch: doxygen_mainpage_was_used != index_include!\")\n\n include_map = {\n \"page_index.rst.include\": index_include,\n os.path.basename(root.page_hierarchy_file): page_hierarchy_include,\n os.path.basename(root.class_hierarchy_file): class_hierarchy_include,\n os.path.basename(root.file_hierarchy_file): file_hierarchy_include,\n os.path.basename(root.unabridged_api_file): unabridged_api_include,\n os.path.basename(root.unabridged_orphan_file): orphan_api_include\n }\n root_file_base = os.path.basename(full_root_file_path)\n for key, val in include_map.items():\n if val:\n check = getattr(self, \"assertTrue\")\n msg = \"*WAS* expected in {root_file_base}, but was *NOT* found!\".format(\n root_file_base=root_file_base\n )\n else:\n check = getattr(self, \"assertFalse\")\n msg = \"was *NOT* expected in {root_file_base}, but *WAS* found!\".format(\n root_file_base=root_file_base\n )\n check(\n key in root_file_includes,\n \"Page '{key}' {msg}\".format(key=key, msg=msg))\n\n # Some tests may want the toctree names afterward.\n return full_api_toctrees, orphan_toctrees","def _add_recurse(self, path_name, dot_name):\n # self.logger.debug(\n # \"_add_recurse({0},{1})\".format(path_name, dot_name))\n\n added_count = 0\n if os.path.isdir(path_name):\n # then is module, such as xmlrpc, with includes:\n # network/tcp_echo/xmlrpc/__init__.py\n # network/tcp_echo/xmlrpc/client.py\n # network/tcp_echo/xmlrpc/server.py\n self.logger.debug(\"Recurse into directory ({})\".format(path_name))\n\n dir_list = os.listdir(path_name)\n for name in dir_list:\n if name == \"__pycache__\":\n self.logger.debug(\n \" skip known skipper ({})\".format(name))\n continue\n\n if name == \"test\":\n self.logger.debug(\n \" skip known skipper ({})\".format(name))\n continue\n\n if name[0] == \".\":\n self.logger.debug(\n \" skip pattern skipper ({})\".format(name))\n continue\n\n # still here, see if file or subdirectory\n file_name = os.path.join(path_name, name)\n if os.path.isdir(file_name):\n # then another sub-directory\n added_count += self._add_recurse(\n file_name, dot_name + '.' + name)\n\n else: # assume is a file?\n # for example, name=client.py\n if name.endswith(\".py\"):\n self.dep_list.append(file_name)\n added_count += 1\n try:\n self.logger.debug(\n \"Recurse into s-file ({})\".format(file_name))\n self.add_file_dependency(file_name)\n\n except FileNotFoundError:\n self.logger.error(\n \"Could NOT find above dependency within\" +\n \"({})\".format(file_name))\n # sys.exit(EXIT_CODE_MISSING_DEP)\n\n else:\n # expects network.tcp_echo.xmlrpc.something.txt\n value = path_name + os.sep + name\n self.logger.debug(\n \"Add file as dependency({})\".format(value))\n self.dep_list.append(value)\n added_count += 1\n\n else:\n # might be file, like network/tcp_echo/ftplib.py as\n # network.tcp_echo.ftplib\n if not path_name.endswith(\".py\"):\n path_name += \".py\"\n self.logger.debug(\"Recurse into d-file ({})\".format(path_name))\n self.add_file_dependency(path_name)\n\n return added_count","def check_all():\n for name, module in sorted(sys.modules.items()): # module files\n filepath = getattr(module, '__file__', None)\n if filepath is None:\n # we land here when a module is an attribute of another module\n # i.e., it exists twice in the sys.modules table, once as its\n # canonical representation, and again having been imported\n # within another module\n continue\n filepath = filepath.endswith(\".pyc\") and filepath[:-1] or filepath\n check_one(filepath)\n\n for filepath in extras: # additional files\n check_one(filepath)","def XXXcheck_class_dependencies(self, node):\n # keep track of types which are used by methods arguments\n used_types = {}\n for method in node[\"methods\"]:\n self.check_function_dependencies(method, used_types)\n\n modules = {}\n for typ in used_types.values():\n if typ.f_module:\n for mname, only in typ.f_module.items():\n module = modules.setdefault(mname, {})\n if only: # Empty list means no ONLY clause\n for oname in only:\n module[oname] = True\n\n # Always add C_PTR, needed for class F_derived_member\n modules.setdefault(\"iso_c_binding\", {})[\"C_PTR\"] = True\n\n F_modules = [] # array of tuples ( name, (only1, only2) )\n for mname in sorted(modules):\n F_modules.append((mname, sorted(modules[mname])))\n node.F_module_dependencies = F_modules","def filter_depend( self, atoms ):\n\n def dep_string_reduce(dep_string,enabled_useflags):\n dest = []\n tokens = iter(dep_string.split())\n useflags = enabled_useflags.split()\n\n for token in tokens:\n if token[-1] == \"?\":\n if token.startswith(\"!\"):\n skip = token[1:-1] in useflags\n else:\n skip = token[:-1] not in useflags\n if skip:\n level = 0\n while 1:\n token = next(tokens)\n if token == \"(\":\n level+=1\n if token == \")\":\n level-=1\n if level < 1:\n break\n continue\n elif token == \"(\" or token == \")\":\n continue\n else:\n dest.append(token)\n\n return \" \".join(dest)\n\n # gjl does not use use flags\n try:\n use = os.environ[\"USE\"]\n atoms = dep_string_reduce(atoms, use)\n except KeyError:\n pass\n return atoms","def test_dependency_interface():\n c = TestClient()\n conanfile = textwrap.dedent(\"\"\"\n from conans import ConanFile\n class Pkg(ConanFile):\n name = \"dep\"\n version = \"1.0\"\n homepage = \"myhome\"\n url = \"myurl\"\n license = \"MIT\"\n \"\"\")\n user = textwrap.dedent(\"\"\"\n from conan import ConanFile\n class User(ConanFile):\n requires = \"dep/1.0\"\n def generate(self):\n self.output.info(\"HOME: {}\".format(self.dependencies[\"dep\"].homepage))\n self.output.info(\"URL: {}\".format(self.dependencies[\"dep\"].url))\n self.output.info(\"LICENSE: {}\".format(self.dependencies[\"dep\"].license))\n self.output.info(\"RECIPE: {}\".format(self.dependencies[\"dep\"].recipe_folder))\n self.output.info(\"CONANDATA: {}\".format(self.dependencies[\"dep\"].conan_data))\n\n \"\"\")\n c.save({\"dep/conanfile.py\": conanfile,\n \"dep/conandata.yml\": \"\",\n \"user/conanfile.py\": user})\n c.run(\"create dep\")\n c.run(\"install user\")\n assert \"conanfile.py: HOME: myhome\" in c.out\n assert \"conanfile.py: URL: myurl\" in c.out\n assert \"conanfile.py: LICENSE: MIT\" in c.out\n assert \"conanfile.py: RECIPE:\" in c.out\n assert \"conanfile.py: CONANDATA: {}\" in c.out","def test_extra_directives(modpath):\n retcode, out = flake8(\n join(modpath, \"RST303/sphinx-directives\"),\n directives=\"req,spec,needfilter\",\n )\n assert not retcode, out","def set_dependency_files(context):\n path_to_direct_file = os.path.abspath('data/gemini_scan_data/direct-dependencies.txt')\n path_to_transitive_file = os.path.abspath('data/gemini_scan_data/transitive-dependencies.txt')\n context.dependency_files = list()\n with open(path_to_direct_file, 'rb') as f:\n context.dependency_files.append((\n \"dependencyFile[]\",\n (\n 'direct-dependencies.txt',\n f.read(),\n 'text/plain'\n )\n ))\n with open(path_to_transitive_file, 'rb') as f:\n context.dependency_files.append((\n \"dependencyFile[]\",\n (\n 'transitive-dependencies.txt',\n f.read(),\n 'text/plain'\n )\n ))","def scanpatch(fp):\n lr = patch.linereader(fp)\n\n def scanwhile(first, p):\n \"\"\"scan lr while predicate holds\"\"\"\n lines = [first]\n while True:\n line = lr.readline()\n if not line:\n break\n if p(line):\n lines.append(line)\n else:\n lr.push(line)\n break\n return lines\n\n while True:\n line = lr.readline()\n if not line:\n break\n if line.startswith('diff --git a/'):\n def notheader(line):\n s = line.split(None, 1)\n return not s or s[0] not in ('---', 'diff')\n header = scanwhile(line, notheader)\n fromfile = lr.readline()\n if fromfile.startswith('---'):\n tofile = lr.readline()\n header += [fromfile, tofile]\n else:\n lr.push(fromfile)\n yield 'file', header\n elif line[0] == ' ':\n yield 'context', scanwhile(line, lambda l: l[0] in ' \\\\')\n elif line[0] in '-+':\n yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\\\')\n else:\n m = lines_re.match(line)\n if m:\n yield 'range', m.groups()\n else:\n raise patch.PatchError('unknown patch content: %r' % line)","def read_line(self, line):\n\t\tparts = line[:line.find(';')].split()\n\t\tfor directive in self.directives:\n\t\t\tif directive in map(str.upper, parts):\n\t\t\t\tinclude = os.path.join(self.path, parts[parts.index(directive) + 1].split('\"')[1])\n\t\t\t\tif include not in self.includes:\n\t\t\t\t\tself.includes.append(include)\n\t\t\t\t\tself.read(include)","def read_file(tp, ignoreincludes):\n ret = []\n filename, f = tp\n\n accumulate = \"\"\n for lineno, line in enumerate(f):\n lineno = lineno + 1 # number from 1\n line = line.strip()\n if not line: # preserve blanks\n ret.append((line, filename, lineno))\n continue\n if line.endswith(\"\\\\\"):\n accumulate += line[0:-1]\n continue\n elif accumulate:\n line = accumulate + line\n accumulate = \"\"\n\n if line:\n line = apply_macros(line)\n\n line = line.strip()\n\n if not line:\n continue\n\n try:\n if line.startswith(\"<\") and line.endswith(\">\"):\n if line.startswith(\"<include\"):\n if not ignoreincludes:\n line = line[1:-1]\n line = line[7:].strip()\n line = line.strip('\"')\n ret.extend(read_file(\n searching_open(line),\n ignoreincludes))\n else:\n ret.append((line, filename, lineno))\n elif line.startswith(\"<transform\"):\n line = line[1:-1]\n add_transform(line, filename, lineno)\n else:\n raise RuntimeError(_(\"unknown command {0}\").format(\n line))\n else:\n ret.append((line, filename, lineno))\n except RuntimeError as e:\n error(_(\"File {file}, line {line:d}: {exception}\").format(\n file=filename,\n line=lineno,\n exception=e),\n exitcode=None)\n raise RuntimeError(\"<included from>\")\n\n return ret","def parse_deps_from_path(self, infile_path, classpath_indexer):\r\n with open(infile_path, 'r') as infile:\r\n return self.parse_deps(infile, classpath_indexer)","def dependencies(spec, request=\"all\"):\n if request not in (\"none\", \"direct\", \"all\"):\n message = \"Wrong value for argument 'request' : \"\n message += \"should be one of ('none', 'direct', 'all')\"\n raise tty.error(message + \" [current value is '%s']\" % request)\n\n if request == \"none\":\n return []\n\n if request == \"direct\":\n return spec.dependencies(deptype=(\"link\", \"run\"))\n\n # FIXME : during module file creation nodes seem to be visited multiple\n # FIXME : times even if cover='nodes' is given. This work around permits\n # FIXME : to get a unique list of spec anyhow. Do we miss a merge\n # FIXME : step among nodes that refer to the same package?\n seen = set()\n seen_add = seen.add\n deps = sorted(\n spec.traverse(order=\"post\", cover=\"nodes\", deptype=(\"link\", \"run\"), root=False),\n reverse=True,\n )\n return [d for d in deps if not (d in seen or seen_add(d))]","def compile_modules(base, output, source, bind=True):\n return compile_files(base, output, source, bind, amd=True)","def moduleCompletion(line):\n def tryImport(mod, only_modules=False):\n def isImportable(module, attr):\n if only_modules:\n return inspect.ismodule(getattr(module, attr))\n else:\n return not(attr[:2] == '__' and attr[-2:] == '__')\n try:\n m = __import__(mod)\n except:\n return []\n mods = mod.split('.')\n for module in mods[1:]:\n m = getattr(m,module)\n if (not hasattr(m, '__file__')) or (not only_modules) or\\\n (hasattr(m, '__file__') and '__init__' in m.__file__):\n completion_list = [attr for attr in dir(m) if isImportable(m, attr)]\n completion_list.extend(getattr(m,'__all__',[]))\n if hasattr(m, '__file__') and '__init__' in m.__file__:\n completion_list.extend(moduleList(os.path.dirname(m.__file__)))\n completion_list = list(set(completion_list))\n if '__init__' in completion_list:\n completion_list.remove('__init__')\n return completion_list\n\n words = line.split(' ')\n if len(words) == 3 and words[0] == 'from':\n return ['import ']\n if len(words) < 3 and (words[0] in ['import','from']) :\n if len(words) == 1:\n return getRootModules()\n mod = words[1].split('.')\n if len(mod) < 2:\n return getRootModules()\n completion_list = tryImport('.'.join(mod[:-1]), True)\n completion_list = ['.'.join(mod[:-1] + [el]) for el in completion_list]\n return completion_list\n if len(words) >= 3 and words[0] == 'from':\n mod = words[1]\n return tryImport(mod)","def _get_transitive_dependencies_helper(self, target, excluded_set, accumulator, depth_limit=30):\n if depth_limit <= 0:\n raise Exception(\"Dependency depth limit exceeded, resolving: %s\" % (str(target),) )\n if target in excluded_set:\n return\n for c in self.get(target).requires:\n if c not in excluded_set:\n self._get_transitive_dependencies_helper(c, excluded_set, accumulator, depth_limit=depth_limit-1)\n accumulator.append(target)\n excluded_set.add(target)","def scan_contents(self, sourcetree, keep_contents, detect_defines):\n # TODO: Consider a more robust regex.\n include_re = r'^\\s*#\\s*include\\s+(?P<quote>[\"<])(?P<path>[^\">]*)[\">]'\n define_re = r'^\\s*#.*define(?:01)?\\s+(\\w*)'\n current_block = None\n with open(self._abspath, 'r') as scanfile:\n contents = scanfile.read()\n lines = contents.splitlines(True)\n for lineno, line in enumerate(lines, 1):\n match = re.match(include_re, line)\n if match:\n is_system = (match.group('quote') == '<')\n includedpath = match.group('path')\n included_file = self._process_include(lineno, is_system,\n includedpath, line, sourcetree)\n if current_block is None:\n current_block = IncludeBlock(included_file)\n self._include_blocks.append(current_block)\n else:\n current_block.add_file(included_file)\n elif line and not line.isspace():\n current_block = None\n if detect_defines:\n self._declared_defines = []\n for line in lines:\n match = re.match(define_re, line)\n if match:\n self._declared_defines.append(match.group(1))\n if keep_contents:\n self._lines = lines","def main():\n argp = argparse.ArgumentParser(prog='-mshlibs', description=('Print the '\n 'complete list of shared libraries used by the specified binary '\n 'file(s), (optionally including all child dependencies)'))\n argp.add_argument('file', nargs='+', help='file(s) to report on')\n argp.add_argument('-a', '--all', action=\"store_true\", help=(\n \"recursively resolve all sub-dependencies\"))\n args = argp.parse_args()\n\n if args.all:\n deps = reduce(lambda a, b: a|b,\n [all_libraries_used(f) for f in args.file])\n else:\n deps = reduce(lambda a, b: set(a)|set(b),\n [libraries_used(f) for f in args.file])\n\n for path in sorted(deps):\n print path","def scan(self):\n exclude_patterns_config = self.doxygen_config.get(\"EXCLUDE_PATTERNS\", [])\n exclude_patterns = [\n pattern.replace(\"*/\", \"**/\") for pattern in exclude_patterns_config\n ]\n file_patterns = self.doxygen_config.get(\"FILE_PATTERNS\", [\"*.c\", \"*.h\"])\n if self.doxygen_config.get(\"RECURSIVE\", [\"YES\"]) == [\"YES\"]:\n file_patterns = [f\"**/{pattern}\" for pattern in file_patterns]\n nodes = []\n names = []\n for node in self.doxygen_input:\n if os.path.isdir(node.abspath()):\n for i in node.ant_glob(incl=file_patterns, excl=exclude_patterns):\n nodes.append(i)\n else:\n nodes.append(node)\n return (nodes, names)","def grep(directory, include, findwhat, recursive=True, ignorecase=False, regexp=False, display=None, reversed=False):\n\tfrom os import walk\n\tfrom os.path import join\n\tfrom fnmatch import fnmatchcase\n\tfrom io import open\n\t\n\tdef __search(findwhat, content, ignorecase, regexp):\n\t\t\"\"\" Search in content string \"\"\"\n\t\tfrom re import search, IGNORECASE\n\t\tif regexp:\n\t\t\tif ignorecase:\n\t\t\t\tflag = IGNORECASE\n\t\t\telse:\n\t\t\t\tflag = 0\n\t\t\tif search(findwhat, content, flag):\n\t\t\t\treturn True\n\t\telse:\n\t\t\tif ignorecase:\n\t\t\t\tcontent = content.lower()\n\t\t\t\tfindwhat = findwhat.lower()\n\t\t\t\t\n\t\t\tif content.find(findwhat) != -1:\n\t\t\t\treturn True\n\t\treturn False\n\n\tdef __grep(findwhat, filename, ignorecase, regexp):\n\t\t\"\"\" Grep string in filename \"\"\"\n\t\tresult = []\n\t\ttry:\n\t\t\tencoding = \"utf8\"\n\t\t\tcontent = open(filename,\"r\", encoding=encoding).read()\n\t\texcept FileNotFoundError:\n\t\t\treturn result\n\t\texcept UnicodeDecodeError:\n\t\t\tencoding = \"latin-1\"\n\t\t\tcontent = open(filename,\"r\", encoding=encoding).read()\n\t\t\t\n\t\tif __search(findwhat, content, ignorecase, regexp):\n\t\t\tlines = open(filename,\"r\", encoding=encoding).readlines()\n\t\t\tlineNumber = 1\n\t\t\tfor line in lines:\n\t\t\t\tif __search(findwhat, line, ignorecase, regexp):\n\t\t\t\t\tresult.append((filename, lineNumber, line.strip()))\n\t\t\t\tlineNumber += 1\n\t\treturn result\n\n\tresult = []\n\tfilesPatterns = include.split(\";\")\n\tfor dirpath, dummy, filenames in walk(directory):\n\t\tfor filename in filenames:\n\t\t\tfor filePattern in filesPatterns:\n\t\t\t\tif recursive or (recursive == False and dirpath == directory):\n\t\t\t\t\tif fnmatchcase(filename, filePattern):\n\t\t\t\t\t\tfilename = join(dirpath,filename)\n\t\t\t\t\t\tfounds = __grep(findwhat, filename, ignorecase, regexp)\n\t\t\t\t\t\tresult += founds\n\t\t\t\t\t\tif display != None:\n\t\t\t\t\t\t\tif reversed == False:\n\t\t\t\t\t\t\t\tfor filename, line, content in founds:\n\t\t\t\t\t\t\t\t\tif type(display) == type(True):\n\t\t\t\t\t\t\t\t\t\tif display:\n\t\t\t\t\t\t\t\t\t\t\tprint(\"%s:%d:%s\"%(filename, line, content))\n\t\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\t\tdisplay(filename, line, content)\n\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\tif founds == []:\n\t\t\t\t\t\t\t\t\tif type(display) == type(True):\n\t\t\t\t\t\t\t\t\t\tif display:\n\t\t\t\t\t\t\t\t\t\t\tprint(\"%s:0:not found\"%(filename, line, content))\n\t\t\t\t\t\t\t\t\telse:\n\t\t\t\t\t\t\t\t\t\tdisplay(filename, 0, \"not found\")\n\t\t\t\t\t\t\t\t\t\n\treturn result","def get_dependency(self):\n targets = [self.language.get_c_code_filename(),\n self.language.get_c_header_filename(),\n self.language.get_python_code_filename(),\n self.language.get_python_autogenerated_module()]\n dependencies = self.language.get_source_files()\n return Dependency(dependencies, targets)","def require():","def all_dependencies(target, dep_context):\n for dep in target.closure(bfs=True, **dep_context.target_closure_kwargs):\n yield dep","def process_modules(self) -> typing.NoReturn:\n\t\tfor moduleName in self.moduleNameSet:\n\t\t\tdetected_encoding = detect_encoding(moduleName)\n\n\t\t\tprint(f\"Processing {moduleName} ({detected_encoding})\")\n\n\t\t\twith open(moduleName, 'r+', encoding=detected_encoding) as fileStream:\n\t\t\t\t# Store the content of the file\n\t\t\t\tfileContent: str = fileStream.read()\n\t\t\t\t# Sets the file's current position at the offset, the position of the read/write pointer within the file\n\t\t\t\tfileStream.seek(0, 0)\n\t\t\t\t# Truncates the file's size\n\t\t\t\tfileStream.truncate()\n\n\t\t\t\t# Process regex patterns\n\t\t\t\tfor regexDict in regexDictList:\n\t\t\t\t\tfileContent = self.process_function(regexDict, fileContent)\n\n\t\t\t\t# Rewrite the processed content of the file\n\t\t\t\tfileStream.write(fileContent)","def main(argv=sys.argv):\n parser = optparse.OptionParser(\n usage=\"\"\"\\\nusage: %prog [options] -o <output_path> <module_path> [exclude_paths, ...]\n\nLook recursively in <module_path> for Python modules and packages and create\na reST file with automodule directives per package in the <output_path>.\n\nNote: By default this script will not overwrite already created files.\"\"\")\n\n parser.add_option('-o', '--output-dir', action='store', dest='destdir',\n help='Directory to place all output', default='')\n parser.add_option('-d', '--maxdepth', action='store', dest='maxdepth',\n help='Maximum depth of submodules to show in the TOC '\n '(default: 4)', type='int', default=4)\n parser.add_option('-f', '--force', action='store_true', dest='force',\n help='Overwrite all the files')\n parser.add_option('-n', '--dry-run', action='store_true', dest='dryrun',\n help='Run the script without creating the files')\n parser.add_option('-T', '--no-toc', action='store_true', dest='notoc',\n help='Don\\'t create the table of contents file')\n parser.add_option('-H', '--doc-header', action='store', dest='header',\n help='Documentation Header (default: Project)',\n default='Project')\n parser.add_option('-s', '--suffix', action='store', dest='suffix',\n help='file suffix (default: rst)', default='rst')\n\n (opts, args) = parser.parse_args(argv[1:])\n\n if not args:\n parser.error('A package path is required.')\n if not opts.destdir:\n parser.error('An output directory is required.')\n rootpath, excludes = args[0], args[1:]\n\n use_module = False\n try:\n __import__(rootpath)\n use_module = True\n except ImportError:\n if not path.isdir(rootpath):\n print >>sys.stderr, '%s is not a directory.' % rootpath\n sys.exit(1)\n use_module = False\n\n if not path.isdir(opts.destdir):\n print '%s is not a valid output directory.' % opts.destdir\n sys.exit(1)\n\n if not use_module:\n excludes = normalize_excludes(rootpath, excludes)\n recurse_tree(rootpath, excludes, opts, use_module)","def _get_dependencies(requirements_file: Path) -> List[str]:\n lines = requirements_file.read_text().strip().split('\\n')\n return [line for line in lines if not line.startswith('#')]","def GetModules(cls, file):\n modules = set([])\n with open(file, 'r') as f:\n lines = f.readlines()\n for line in lines:\n for sig in ModuleFinder.__signatures:\n match = sig.match(line)\n if match:\n module = match[1].split('.')[0]\n # Remove alias:\n module = ModuleFinder.__removeAlias.sub('', module)\n modules.add(module)\n break\n return modules","def defined_submodule(arr):\n return any([el.endswith('_module]') for el in arr])","def test_dependencies_visit_build_requires_profile():\n # https://github.com/conan-io/conan/issues/10304\n client = TestClient()\n client.save({\"conanfile.py\": GenConanfile()})\n client.run(\"create . cmake/0.1@\")\n conanfile = textwrap.dedent(\"\"\"\n from conans import ConanFile\n class Pkg(ConanFile):\n\n def validate(self):\n self.output.info(\"VALIDATE DEPS: {}!!!\".format(len(self.dependencies.items())))\n\n def generate(self):\n for req, dep in self.dependencies.items():\n self.output.info(\"GENERATE REQUIRE: {}!!!\".format(dep.ref))\n dep = self.dependencies.build[\"cmake\"]\n self.output.info(\"GENERATE CMAKE: {}!!!\".format(dep.ref))\n \"\"\")\n client.save({\"conanfile.py\": conanfile,\n \"profile\": \"[build_requires]\\ncmake/0.1\"})\n client.run(\"install . -pr:b=default -pr:h=profile --build\") # Use 2 contexts\n # Validate time, build-requires not available yet\n assert \"conanfile.py: VALIDATE DEPS: 0!!!\" in client.out\n # generate time, build-requires already available\n assert \"conanfile.py: GENERATE REQUIRE: cmake/0.1!!!\" in client.out\n assert \"conanfile.py: GENERATE CMAKE: cmake/0.1!!!\" in client.out","def checkRequiredDependencies(self):\n \n # skip dependency check for downloading only\n if( self.downloadOnly ):\n return\n\n # hard dependencies\n for req in self.reqmodules:\n if( self.parent.module(req) == None ):\n # check if there is an auto detected module\n if( self.parent.module(req, True) == None ):\n self.abort( self.name + \" requires \" + req \\\n + \" and it wasn't found in your config file!!\" )\n else:\n # use auto detected module\n self.parent.use( self.parent.module(req, True) )\n self.parent.module( req ).init()\n\n print self.name + \": auto-detected \" + req + \" version \" + self.parent.module( req ).version\n \n # build only dependencies\n if( self.mode == \"install\" ):\n mods = self.reqmodules_buildonly + self.reqmodules_external\n for req in mods:\n if( self.parent.module(req) == None ):\n # check if there is an auto detected module\n if( self.parent.module(req, True) == None ):\n self.abort( req + \" not found in your config file!! \" + self.name \\\n + \" cannot be built without \" + req )\n else:\n # use auto detected module\n self.parent.use( self.parent.module(req, True) )\n self.parent.module( req ).init()\n\n print \" - \" + self.name + \": auto-detected \" + req + \" version \" + self.parent.module( req ).version","def clsources(ctx):\n\t# TODO Use regex instead\n\t# this is a poor-man's hack, it relies on the assumption that files\n\t# start and end with parenthesis. Put a comment before, and you generate\n\t# wrong code. But the source is under my control anyways.\n\tfloat_srcfolder = ctx.path.find_node(inc + \"/ukoct/opencl/float/sources\")\n\tcommon_clsources = ctx.path.ant_glob(inc + \"/ukoct/opencl/common/**/*.cl\")\n\tfloat_clsources = [\n\t\tfloat_srcfolder.find_node(\"defs.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"coherent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"consistent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"intConsistent.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"closed.inc.cl\"),\n\t\tfloat_srcfolder.find_node(\"stronglyClosed.inc.cl\"),\n\t]\n\tfloat_clsource = []\n\tfor node in common_clsources:\n\t\tsource = node.read()\n\t\tfloat_clsource.append(source[source.find(\"(\") + 1 : source.rfind(\")\")])\n\tfor node in float_clsources:\n\t\tsource = node.read()\n\t\tfloat_clsource.append(source[source.find(\"(\") + 1 : source.rfind(\")\")])\n\tctx.path.make_node(\"float.cl\").write(''.join(float_clsource))","def get_makefile_dependencies(self, template: Union[Path, str]) -> List[Path]:\n if isinstance(template, Path):\n template = template.read_text()\n dependencies = self.variable_files + self.yasha_extensions_files\n referenced_template_partials = find_referenced_templates(self.env.parse(template)) # returns a generator\n # convert the generator to a list, filtering out the None values\n referenced_template_partials: List[str] = list(filter(bool, referenced_template_partials))\n\n for relative_path in referenced_template_partials:\n for basepath in self.env.loader.searchpath: # type: ignore\n if not isinstance(basepath, Path): basepath = Path(basepath)\n template_path = basepath / relative_path\n if template_path.is_file:\n # we've found the template partial inside this basepath\n dependencies.append(template_path)\n return dependencies","def check_custom_deps(path, deps):\n for key, value in deps.items():\n for regex in value['regex']:\n if re.match(r'' + regex, path):\n return key\n return None","def test_include(f2003_create):\n # Use the Main Program rule R1101 as an example\n startcls = F2003.Program_Stmt\n subclasses = [\n F2003.Specification_Part,\n F2003.Execution_Part,\n F2003.Internal_Subprogram_Part,\n ]\n endcls = F2003.End_Program_Stmt\n reader = get_reader(\n (\n \"include '1'\\n\"\n \"! comment1\\n\"\n \"program test\\n\"\n \"include '2'\\n\"\n \"! comment2\\n\"\n \"integer :: i\\n\"\n \"include '3'\\n\"\n \"! comment3\\n\"\n \"i=1\\n\"\n \"include '4'\\n\"\n \"! comment4\\n\"\n \"contains\\n\"\n \"include '5'\\n\"\n \"! comment5\\n\"\n \"end program test\\n\"\n \"! I should be ignored\"\n \"include 'so should I'\"\n ),\n ignore_comments=False,\n )\n result = BlockBase.match(startcls, subclasses, endcls, reader)\n assert (\n \"([Include_Stmt(Include_Filename('1')), Comment('! comment1'), \"\n \"Program_Stmt('PROGRAM', Name('test')), Specification_Part(\"\n \"Implicit_Part(Include_Stmt(Include_Filename('2')), \"\n \"Comment('! comment2')), Type_Declaration_Stmt(Intrinsic_Type_Spec(\"\n \"'INTEGER', None), None, Entity_Decl_List(',', (Entity_Decl(Name(\"\n \"'i'), None, None, None),))), Implicit_Part(Include_Stmt(\"\n \"Include_Filename('3')), Comment('! comment3'))), Execution_Part(\"\n \"Assignment_Stmt(Name('i'), '=', Int_Literal_Constant('1', None)), \"\n \"Include_Stmt(Include_Filename('4')), Comment('! comment4')), \"\n \"Internal_Subprogram_Part(Contains_Stmt('CONTAINS'), Include_Stmt(\"\n \"Include_Filename('5')), Comment('! comment5')), End_Program_Stmt(\"\n \"'PROGRAM', Name('test'))],)\" in str(result).replace(\"u'\", \"'\")\n )\n assert \"should\" not in str(result)","def _parse_gradle_files(moduleDir: str, gradleFilepaths: Set[str])\\\n -> List[ModuleInfo]:\n\n moduleInfo = []\n\n for filepath in gradleFilepaths:\n with open(filepath, 'r') as f:\n for l in f:\n line = l.strip()\n if line and GRADLE_PROJECT_NAME_REGEX.match(l):\n moduleInfo.append(ModuleInfo(moduleDir, filepath, set()))\n break\n\n return moduleInfo","def _set_dependencies(self, analysis, path):\n for toc in (analysis.binaries, analysis.datas):\n for i, tpl in enumerate(toc):\n if not tpl[1] in self._dependencies:\n logger.debug(\"Adding dependency %s located in %s\", tpl[1], path)\n self._dependencies[tpl[1]] = path\n else:\n dep_path = self._get_relative_path(path, self._dependencies[tpl[1]])\n # Ignore references that point to the origin package. This can happen if the same resource is listed\n # multiple times in TOCs (e.g., once as binary and once as data).\n if dep_path.endswith(path):\n logger.debug(\n \"Ignoring self-reference of %s for %s, located in %s - duplicated TOC entry?\", tpl[1], path,\n dep_path\n )\n # Clear the entry as it is a duplicate.\n toc[i] = (None, None, None)\n continue\n logger.debug(\"Referencing %s to be a dependency for %s, located in %s\", tpl[1], path, dep_path)\n # Determine the path relative to dep_path (i.e, within the target directory) from the 'name'\n # component of the TOC tuple. If entry is EXTENSION, then the relative path needs to be\n # reconstructed from the name components.\n if tpl[2] == 'EXTENSION':\n # Split on os.path.sep first, to handle additional path prefix (e.g., lib-dynload)\n ext_components = tpl[0].split(os.path.sep)\n ext_components = ext_components[:-1] + ext_components[-1].split('.')[:-1]\n if ext_components:\n rel_path = os.path.join(*ext_components)\n else:\n rel_path = ''\n else:\n rel_path = os.path.dirname(tpl[0])\n # Take filename from 'path' (second component of TOC tuple); this way, we don't need to worry about\n # suffix of extensions.\n filename = os.path.basename(tpl[1])\n # Construct the full file path relative to dep_path...\n filename = os.path.join(rel_path, filename)\n # ...and use it in new DEPENDENCY entry\n analysis.dependencies.append((\":\".join((dep_path, filename)), tpl[1], \"DEPENDENCY\"))\n toc[i] = (None, None, None)\n # Clean the list\n toc[:] = [tpl for tpl in toc if tpl != (None, None, None)]","def expand_files(self, recursive=True, include_buildfile=True):\r\n\r\n files = []\r\n\r\n def _expand(target):\r\n files.extend([os.path.abspath(os.path.join(target.target_base, s))\r\n for s in (target.sources or [])])\r\n if include_buildfile:\r\n files.append(target.address.buildfile.full_path)\r\n if recursive:\r\n for dep in target.dependencies:\r\n if isinstance(dep, TargetWithSources):\r\n _expand(dep)\r\n elif hasattr(dep, 'address'):\r\n # Don't know what it is, but we'll include the BUILD file to be paranoid\r\n files.append(dep.address.buildfile.full_path)\r\n\r\n _expand(self)\r\n return files","def add_dependency(kernel, insn_match, depends_on):\n\n if isinstance(depends_on, str) and depends_on in kernel.id_to_insn:\n added_deps = frozenset([depends_on])\n else:\n added_deps = frozenset(\n dep.id for dep in find_instructions_in_single_kernel(kernel,\n depends_on))\n\n if not added_deps:\n raise LoopyError(\"no instructions found matching '%s' \"\n \"(to add as dependencies)\" % depends_on)\n\n matched = [False]\n\n def add_dep(insn):\n new_deps = insn.depends_on\n matched[0] = True\n if new_deps is None:\n new_deps = added_deps\n else:\n new_deps = new_deps | added_deps\n\n return insn.copy(depends_on=new_deps)\n\n result = map_instructions(kernel, insn_match, add_dep)\n\n if not matched[0]:\n raise LoopyError(\"no instructions found matching '%s' \"\n \"(to which dependencies would be added)\" % insn_match)\n\n return result","def parse_dependency_links(*filenames):\n dependency_links = []\n for f in filenames:\n for line in open(f, 'r').read().split('\\n'):\n if re.match(r'\\s*-[ef]\\s+', line):\n line = re.sub(r'\\s*-[ef]\\s+', '', line)\n line = re.sub(r'\\s*git\\+https', 'http', line)\n line = re.sub(r'\\.git#', '/tarball/master#', line)\n dependency_links.append(line)\n return dependency_links","def analyse_files_against_regex_pattern(files, pattern):\n # boolean to check if docs are to be generated\n comments_for_jsdoc_exists = False\n # reading file content and comparing with pattern\n for filepath in files:\n if comments_for_jsdoc_exists:\n break\n with open(filepath, encoding='utf-8') as code:\n file_content = code.read()\n matches = pattern.search(file_content)\n if matches:\n comments_for_jsdoc_exists = True\n break\n\n return comments_for_jsdoc_exists","def checkDependencies(check=True):\n modules = []\n f = open(CONST_REQUIREMENTS_FILE)\n for line in f:\n if line.find('#'):\n modules.append([line[:line.index('=')], (line[line.index('=')+2:]).strip()])\n f.close()\n\n for module in modules:\n try:\n __import__(module[0])\n except ImportError: \n if query_user_bool(\"Missing module %s.\" \\\n \" Do you wish to install it?\" % module[0]):\n subprocess.call([\"pip2\", \"install\", \"%s==%s\" %\n (module[0], module[1])])\n \n else:\n return False\n return True","def test_case_6():\n print(\"*********Test_case_6***********\")\n path = os.path.join(os.path.dirname(__file__), 'testdir', 't1.c')\n result = find_files('.c', path)\n print(result)","def test_case_3():\n print(\"*********Test_case_3***********\")\n result = find_files('.c', None)\n print(result)","def find_dependencies(self, dependent_rev, recurse=None):\n if recurse is None:\n recurse = self.options.recurse\n\n try:\n dependent = self.get_commit(dependent_rev)\n except InvalidCommitish as e:\n abort(e.message())\n\n self.todo.append(dependent)\n self.todo_d[dependent.hex] = True\n\n while self.todo:\n sha1s = [commit.hex[:8] for commit in self.todo]\n self.logger.debug(\"TODO list: %s\" % \" \".join(sha1s))\n dependent = self.todo.pop(0)\n del self.todo_d[dependent.hex]\n self.logger.debug(\"Processing %s from TODO list\" %\n dependent.hex[:8])\n self.notify_listeners('new_commit', dependent)\n\n for parent in dependent.parents:\n self.find_dependencies_with_parent(dependent, parent)\n self.done.append(dependent.hex)\n self.done_d[dependent.hex] = True\n self.logger.debug(\"Found all dependencies for %s\" %\n dependent.hex[:8])\n # A commit won't have any dependencies if it only added new files\n dependencies = self.dependencies.get(dependent.hex, {})\n self.notify_listeners('dependent_done', dependent, dependencies)\n\n self.notify_listeners('all_done')","def check_file_valid_input(config, modname, fname, fdict, indent=''):\n\n cnts = [0] * NUMCNTS\n\n # check that any given filename pattern has a definition\n if pfwdefs.SW_FILEPAT in fdict:\n cnts2 = check_filepat_valid(config, fdict[pfwdefs.SW_FILEPAT], modname, fname, indent+' ')\n cnts = [x + y for x, y in zip(cnts, cnts2)] # increment counts\n\n # check that it has filepat, filename, depends, or query wcl (required)\n # if filename is a pattern, can I check that all needed values exist?\n # todo check depends happens in same block previous to this module\n if (('listonly' not in fdict or not miscutils.convertBool(fdict['listonly'])) and\n pfwdefs.SW_FILEPAT not in fdict and pfwdefs.FILENAME not in fdict and\n 'fullname' not in fdict and 'query_fields' not in fdict and pfwdefs.DATA_DEPENDS not in fdict):\n error(indent, \"module %s, %s, %s - Missing terms needed to determine input filename\" % (modname, pfwdefs.SW_INPUTS, fname))\n cnts[ERRCNT_POS] += 1\n\n # check that it has pfwdefs.DIRPAT : err\n # can I check that all values for pfwdefs.DIRPAT exist?\n if pfwdefs.DIRPAT not in fdict:\n error(indent, \"module %s, %s, %s - Missing %s\" % (modname, pfwdefs.SW_INPUTS, fname, pfwdefs.DIRPAT))\n cnts[ERRCNT_POS] += 1\n\n return cnts","def learn_requirements():\n req_file = \"requirements.txt\"\n reqs = []\n\n import os\n\n path = os.path.dirname(__file__)\n req_file = os.path.join(path, \"..\", req_file)\n if not os.path.exists(req_file):\n # not needed with installed package\n return reqs\n\n excludes = \"versioneer coveralls coverage\".split()\n with open(req_file, \"r\") as fp:\n buf = fp.read().strip().splitlines()\n for req in buf:\n req = req.strip()\n if (\n req != \"\"\n and not req.startswith(\"#\")\n and req not in excludes\n ):\n reqs.append(req)\n return reqs","def get_requires(path=REQUIRE_PATH):\n for line in read(path).splitlines():\n line = line.strip()\n if line and not line.startswith('#'):\n yield line","def strict_dependencies(target, dep_context):\n for declared in _resolve_aliases(target):\n if isinstance(declared, dep_context.compiler_plugin_types):\n for r in declared.closure(bfs=True, **dep_context.target_closure_kwargs):\n yield r\n else:\n yield declared","def find_modules(inFile):\n pkgName= determinePackage(inFile)\n fileDir= os.path.dirname(inFile)\n files= os.listdir(fileDir)\n \n files= [ os.path.join( fileDir, aFile) for aFile in files if aFile.endswith(\".py\") ]\n \n moduleDict= {}\n for aFile in files:\n fileNoExtName= os.path.basename(aFile)[:-3]\n \n \n if pkgName is None:\n modObj= importlib.import_module( fileNoExtName, fileDir )\n else:\n pkgAndFile= \".\".join( [pkgName, fileNoExtName] )\n modObj= importlib.import_module( pkgAndFile, os.path.dirname(fileDir) )\n \n moduleDict[aFile]= modObj\n \n return moduleDict","def run(self):\n\n # from sphynx Include Directive in https://github.com/sphinx-doc/sphinx/blob/master/sphinx/directives/other.py\n # type: () -> List[nodes.Node]\n env = self.state.document.settings.env\n if self.arguments[0].startswith('<') and \\\n self.arguments[0].endswith('>'):\n # docutils \"standard\" includes, do not do path processing\n return BaseInclude.run(self)\n rel_filename, filename = env.relfn2path(self.arguments[0])\n self.arguments[0] = filename\n env.note_included(filename)\n #end\n\n if not self.state.document.settings.file_insertion_enabled:\n raise self.warning('\"%s\" directive disabled.' % self.name)\n source = self.state_machine.input_lines.source(\n self.lineno - self.state_machine.input_offset - 1)\n source_dir = os.path.dirname(os.path.abspath(source))\n path = directives.path(self.arguments[0])\n if path.startswith('<') and path.endswith('>'):\n path = os.path.join(self.standard_include_path, path[1:-1])\n path = os.path.normpath(os.path.join(source_dir, path))\n path = utils.relative_path(None, path)\n path = nodes.reprunicode(path)\n encoding = self.options.get(\n 'encoding', self.state.document.settings.input_encoding)\n e_handler=self.state.document.settings.input_encoding_error_handler\n tab_width = self.options.get(\n 'tab-width', self.state.document.settings.tab_width)\n try:\n self.state.document.settings.record_dependencies.add(path)\n include_file = io.FileInput(source_path=path,\n encoding=encoding,\n error_handler=e_handler)\n except UnicodeEncodeError as error:\n raise self.severe(u'Problems with \"%s\" directive path:\\n'\n 'Cannot encode input file path \"%s\" '\n '(wrong locale?).' %\n (self.name, SafeString(path)))\n except IOError as error:\n raise self.severe(u'Problems with \"%s\" directive path:\\n%s.' %\n (self.name, ErrorString(error)))\n startline = self.options.get('start-line', None)\n endline = self.options.get('end-line', None)\n try:\n if startline or (endline is not None):\n lines = include_file.readlines()\n rawtext = ''.join(lines[startline:endline])\n else:\n rawtext = include_file.read()\n except UnicodeError as error:\n raise self.severe(u'Problem with \"%s\" directive:\\n%s' %\n (self.name, ErrorString(error)))\n # start-after/end-before: no restrictions on newlines in match-text,\n # and no restrictions on matching inside lines vs. line boundaries\n after_text = self.options.get('start-after', None)\n if after_text:\n # skip content in rawtext before *and incl.* a matching text\n after_index = rawtext.find(after_text)\n if after_index < 0:\n raise self.severe('Problem with \"start-after\" option of \"%s\" '\n 'directive:\\nText not found.' % self.name)\n rawtext = rawtext[after_index + len(after_text):]\n before_text = self.options.get('end-before', None)\n if before_text:\n # skip content in rawtext after *and incl.* a matching text\n before_index = rawtext.find(before_text)\n if before_index < 0:\n raise self.severe('Problem with \"end-before\" option of \"%s\" '\n 'directive:\\nText not found.' % self.name)\n rawtext = rawtext[:before_index]\n\n # Handle alternate comment styles\n style = self.options.get('style', 'C-style')\n if style not in COMMENT_STYLES:\n raise self.severe('Cannot find comment style \"%s\", not in %s'\n % (style, COMMENT_STYLES.keys()))\n self.comment_options = COMMENT_STYLES[style]\n\n rawtext = self.filterText(rawtext)\n #if (path == \"../examples/neuropil_hydra.c\"):\n #raise self.severe('filterd text from %s:\\n%s' % (path, rawtext))\n\n include_lines = statemachine.string2lines(rawtext, tab_width,\n convert_whitespace=True)\n if 'literal' in self.options:\n # Convert tabs to spaces, if `tab_width` is positive.\n if tab_width >= 0:\n text = rawtext.expandtabs(tab_width)\n else:\n text = rawtext\n literal_block = nodes.literal_block(rawtext, source=path,\n classes=self.options.get('class', []))\n literal_block.line = 1\n self.add_name(literal_block)\n if 'number-lines' in self.options:\n try:\n startline = int(self.options['number-lines'] or 1)\n except ValueError:\n raise self.error(':number-lines: with non-integer '\n 'start value')\n endline = startline + len(include_lines)\n if text.endswith('\\n'):\n text = text[:-1]\n tokens = NumberLines([([], text)], startline, endline)\n for classes, value in tokens:\n if classes:\n literal_block += nodes.inline(value, value,\n classes=classes)\n else:\n literal_block += nodes.Text(value, value)\n else:\n literal_block += nodes.Text(text, text)\n return [literal_block]\n if 'code' in self.options:\n self.options['source'] = path\n codeblock = CodeBlock(self.name,\n [self.options.pop('code')], # arguments\n self.options,\n include_lines, # content\n self.lineno,\n self.content_offset,\n self.block_text,\n self.state,\n self.state_machine)\n return codeblock.run()\n\n self.state_machine.insert_input(include_lines, path)\n return []","def main():\n args = docopt(__doc__)\n meta = fetch_metadata(args['DIRECTORY'], **args)\n if args['--fasta']:\n meta.assembly.update({'file': args['--fasta']})\n taxdump = None\n dependencies = {}\n for field in FIELDS:\n if args[field['flag']]:\n for dep in field['depends']:\n if dep not in dependencies or not dependencies[dep]:\n dependencies[dep] = fetch_field(args['DIRECTORY'], dep, meta)\n if field['flag'] == '--hits':\n if not taxdump:\n taxdump = fetch_taxdump(args['--taxdump'])\n parents = field['module'].parent()\n parsed = field['module'].parse(\n args[field['flag']],\n **{key: args[key] for key in PARAMS},\n taxdump=taxdump,\n dependencies=dependencies,\n meta=meta)\n if not isinstance(parsed, list):\n parsed = [parsed]\n for data in parsed:\n if not args['--replace']:\n if has_field_warning(meta, data.field_id):\n continue\n for parent in data.parents:\n if 'range' in parent:\n parent_meta = meta.field_meta(parent['id'])\n if parent_meta and 'range' in parent_meta:\n parent['range'][0] = min(parent['range'][0], parent_meta['range'][0])\n parent['range'][1] = max(parent['range'][1], parent_meta['range'][1])\n meta.add_field(parents+data.parents, **data.meta)\n if isinstance(data, Identifier):\n meta.records = len(data.values)\n json_file = \"%s/%s.json\" % (args['DIRECTORY'], data.field_id)\n file_io.write_file(json_file, data.values_to_dict())\n dependencies[data.field_id] = data\n if 'identifiers' not in dependencies:\n dependencies['identifiers'] = fetch_field(args['DIRECTORY'], 'identifiers', meta)\n for string in args['--link']:\n link.add(string, meta, dependencies['identifiers'].values, args['--skip-link-test'])\n for string in args['--key']:\n key.add(string, meta)\n if args['--taxid']:\n if not taxdump:\n taxdump = fetch_taxdump(args['--taxdump'])\n taxid.add(args['--taxid'], taxdump, meta)\n file_io.write_file(\"%s/meta.json\" % args['DIRECTORY'], meta.to_dict())","def test_module_doc():\r\n\r\n for fname in os.listdir('.'):\r\n if fname.endswith('.py'):\r\n f = fname.split('.')[0]\r\n print 'Executing ', fname\r\n execfile(fname, locals())","def get_includes(self):\r\n def visitor(fobj, lptr, depth, includes):\r\n if depth > 0:\r\n loc = lptr.contents\r\n includes.append(FileInclusion(loc.file, File(fobj), loc, depth))\r\n\r\n # Automatically adapt CIndex/ctype pointers to python objects\r\n includes = []\r\n conf.lib.clang_getInclusions(self,\r\n callbacks['translation_unit_includes'](visitor), includes)\r\n\r\n return iter(includes)","def crunch(self):\n while True:\n lst = self.want_line(r'\\s*\\.file\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.globl\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.ident\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.section\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.type\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.size\\s+(.*)')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.(bss)\\s+')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.(data)\\s+')\n if lst:\n self.erase(lst[0])\n continue\n lst = self.want_line(r'\\s*\\.(text)\\s+')\n if lst:\n self.erase(lst[0])\n continue\n break\n if osarch_is_amd64():\n self.crunch_amd64(lst)\n elif osarch_is_ia32():\n self.crunch_ia32(lst)\n self.__tag = None","def findModule(name):","def parse_dependency(dep, forge):\n if '|' in dep:\n return [parse_dependency(alt, forge) for alt in dep.split('|')]\n dep = dep.strip()\n name = ''\n version = ''\n arch = ''\n version, dep = extract_text(dep)\n arch, dep = extract_text(dep, ('[', ']'))\n name = dep.strip()\n return {'forge': forge, 'product': name,\n 'constraints': use_mvn_spec(version), 'architectures': arch}","def get_dependencies_content():\n import trustedanalytics\n dependencies = []\n for filename in trustedanalytics.udf_dependencies:\n name, content = _get_file_content_as_str(filename)\n dependencies.append({'file_name': name, 'file_content': content})\n return dependencies"],"string":"[\n \"def scan_fortran_module_outputs(self, target):\\n if self.use_dyndeps_for_fortran():\\n return\\n compiler = None\\n # TODO other compilers\\n for lang, c in self.environment.coredata.compilers.host.items():\\n if lang == 'fortran':\\n compiler = c\\n break\\n if compiler is None:\\n self.fortran_deps[target.get_basename()] = {}\\n return\\n\\n modre = re.compile(FORTRAN_MODULE_PAT, re.IGNORECASE)\\n submodre = re.compile(FORTRAN_SUBMOD_PAT, re.IGNORECASE)\\n module_files = {}\\n submodule_files = {}\\n for s in target.get_sources():\\n # FIXME, does not work for Fortran sources generated by\\n # custom_target() and generator() as those are run after\\n # the configuration (configure_file() is OK)\\n if not compiler.can_compile(s):\\n continue\\n filename = s.absolute_path(self.environment.get_source_dir(),\\n self.environment.get_build_dir())\\n # Fortran keywords must be ASCII.\\n with open(filename, encoding='ascii', errors='ignore') as f:\\n for line in f:\\n modmatch = modre.match(line)\\n if modmatch is not None:\\n modname = modmatch.group(1).lower()\\n if modname in module_files:\\n raise InvalidArguments(\\n f'Namespace collision: module {modname} defined in '\\n f'two files {module_files[modname]} and {s}.')\\n module_files[modname] = s\\n else:\\n submodmatch = submodre.match(line)\\n if submodmatch is not None:\\n # '_' is arbitrarily used to distinguish submod from mod.\\n parents = submodmatch.group(1).lower().split(':')\\n submodname = parents[0] + '_' + submodmatch.group(2).lower()\\n\\n if submodname in submodule_files:\\n raise InvalidArguments(\\n f'Namespace collision: submodule {submodname} defined in '\\n f'two files {submodule_files[submodname]} and {s}.')\\n submodule_files[submodname] = s\\n\\n self.fortran_deps[target.get_basename()] = {**module_files, **submodule_files}\",\n \"def used_mods(ffile):\\n import re\\n import codecs\\n\\n # Go through line by line,\\n # remove comments and strings because the latter can include ';'.\\n # Then split at at ';', if given.\\n # The stripped line should start with 'use '.\\n # After use should be the \\\"module_name\\\", ', intrinsic :: module_name', or\\n # ', non_intrinsic :: module_name'. We allow also to use \\\":: module_name\\\"\\n # After module name should only be ', only: ...' or ', a ==> b'\\n olist = list()\\n of = codecs.open(ffile, 'r', encoding='ascii', errors='ignore')\\n for line in of:\\n ll = line.rstrip().lower() # everything lower case\\n ll = re.sub('!.*$', '', ll) # remove F90 comment\\n ll = re.sub('^c.*$', '', ll) # remove F77 comments\\n ll = re.sub('\\\".*?\\\"', '', ll) # remove \\\"string\\\"\\n ll = re.sub(\\\"'.*?'\\\", '', ll) # remove 'string'\\n # check if several commands are on one line\\n if ';' in ll:\\n lll = ll.split(';')\\n else:\\n lll = [ll]\\n for il in lll:\\n iil = il.strip()\\n # line should start with 'use '\\n if iil.startswith('use '):\\n iil = iil[4:].strip() # remove 'use '\\n # skip intrinsic modules\\n if 'intrinsic' in iil:\\n if 'non_intrinsic' in iil:\\n iil = re.sub(', *non_intrinsic', '', iil)\\n iil = iil.strip()\\n else:\\n continue # skip to next in lll\\n if iil.startswith('::'):\\n iil = iil[2:].strip() # remove ':: '\\n # remove after ',' if rename-list or only-list\\n iil = re.sub(',.*$', '', iil)\\n olist.append(iil.strip())\\n of.close()\\n\\n return olist\",\n \"def parse_deps():\\n Files = []\\n Dependencies = []\\n TimeBins = ['recover_parameters', 'startup', 'wragh', 'paramcheck',\\n 'preregridinitial', 'postregridinitial', 'basegrid', \\n 'initial', 'postinitial', 'postrestrictinitial', \\n 'postpostinitial', 'recover_variables', \\n 'post_recover_variables', 'cpinitial', 'checkpoint', \\n 'preregrid', 'postregrid', 'prestep', 'evol', 'postrestrict', \\n 'poststep', 'analysis', 'terminate', 'shutdown']\\n\\n implement_re = re.compile('implements:\\\\s*(\\\\w+)', re.I)\\n inherit_re = re.compile('inherits:\\\\s*(.+)', re.I)\\n provides_function_re = re.compile('PROVIDES\\\\s+FUNCTION\\\\s+(\\\\w+)', re.I)\\n uses_function_re = re.compile('USES\\\\s+FUNCTION\\\\s+(\\\\w+)', re.I)\\n requires_function_re = re.compile('REQUIRES\\\\s+FUNCTION\\\\s+(\\\\w+)', re.I)\\n shares_re = re.compile('shares:\\\\s*(\\\\w+)', re.I)\\n requires_thorn_re = re.compile('REQUIRES\\\\s+(?!FUNCTION\\\\s*)(\\\\w+)', re.I)\\n schedules_function_re = re.compile('schedule\\\\s+(?:group\\\\s+)?(\\\\w+)\\\\s+(?:in|at)\\\\s+(\\\\w+)', re.I)\\n\\n # find all interface.ccl and param.ccl files in cwd\\n Cactus_Path = os.path.expanduser('~/Cactus/')\\n for dirpath, dirnames, filenames in os.walk(Cactus_Path + 'arrangements', followlinks=True):\\n for file in filenames:\\n if file == 'interface.ccl':\\n Files.append(os.path.join(dirpath, file))\\n\\n for file in Files:\\n # first parse interface.ccl\\n try:\\n fptr = open(file, 'r')\\n except IOError:\\n print(\\\"Could not open %s\\\" % file) \\n\\n lines = fptr.readlines()\\n\\n try:\\n fptr.close()\\n except IOError:\\n print(\\\"Could not close %s\\\" % file) \\n\\n # then parse param.ccl\\n file = re.sub('interface.ccl', 'param.ccl', file)\\n\\n try:\\n fptr = open(file, 'r')\\n except IOError:\\n print(\\\"Could not open %s\\\" % file) \\n\\n lines += fptr.readlines()\\n\\n try:\\n fptr.close()\\n except IOError:\\n print(\\\"Could not close %s\\\" % file) \\n\\n # then configuration.ccl\\n file = re.sub('param.ccl', 'configuration.ccl', file)\\n\\n try:\\n fptr = open(file, 'r')\\n lines += fptr.readlines()\\n fptr.close()\\n except IOError:\\n pass\\n\\n # then schedule.ccl\\n file = re.sub('configuration.ccl', 'schedule.ccl', file)\\n\\n try:\\n fptr = open(file, 'r')\\n lines += fptr.readlines()\\n fptr.close()\\n except IOError:\\n pass\\n\\n # get the thorn dir and its parent\\n thornname = os.path.basename(os.path.dirname(file))\\n parentdir = os.path.basename(os.path.dirname(os.path.dirname(file)))\\n thornname = os.path.join(parentdir, thornname)\\n file_dict = {'name' : thornname.lower()}\\n for line in lines:\\n line = line.strip()\\n m = re.match(implement_re, line)\\n if m:\\n file_dict['implements'] = m.group(1).lower()\\n\\n m = re.match(inherit_re, line)\\n if m:\\n inheritance = re.split('\\\\W+', m.group(1).lower())\\n file_dict['inherits'] = inheritance\\n\\n m = re.match(provides_function_re, line)\\n if m:\\n try:\\n file_dict['provides_function'].append(m.group(1).lower())\\n except KeyError:\\n file_dict['provides_function'] = [m.group(1).lower()]\\n\\n m = re.match(uses_function_re, line)\\n if m:\\n try:\\n file_dict['uses_function'].append(m.group(1).lower())\\n except KeyError:\\n file_dict['uses_function'] = [m.group(1).lower()]\\n\\n m = re.match(requires_function_re, line)\\n if m:\\n try:\\n file_dict['requires_function'].append(m.group(1).lower())\\n except KeyError:\\n file_dict['requires_function'] = [m.group(1).lower()]\\n\\n m = re.match(requires_thorn_re, line)\\n if m:\\n requires = re.split('\\\\W+', m.group(1).lower())\\n # sometimes we have 'REQUIRES THORNS' instead of 'REQUIRES'\\n if requires[0].lower() == 'thorns':\\n del requires[0]\\n file_dict['requires_thorn'] = requires\\n\\n m = re.match(shares_re, line)\\n if m:\\n try:\\n file_dict['shares'].append(m.group(1).lower())\\n except KeyError:\\n file_dict['shares'] = [m.group(1).lower()]\\n\\n m = re.match(schedules_function_re, line)\\n if m:\\n bin, func = m.group(2).lower(), m.group(1).lower()\\n if bin in TimeBins:\\n bin = 'cctk_' + bin\\n func_dict = {bin : func}\\n try:\\n file_dict['schedules_function'].append(func_dict)\\n except KeyError:\\n file_dict['schedules_function'] = [func_dict]\\n\\n\\n Dependencies.append(file_dict)\\n\\n return Dependencies\",\n \"def parse_deps(self, infile, classpath_indexer):\\r\\n raise NotImplementedError()\",\n \"def get_fortran_deps(self, compiler: FortranCompiler, src: Path, target) -> T.List[str]:\\n if self.use_dyndeps_for_fortran():\\n return []\\n\\n dirname = Path(self.get_target_private_dir(target))\\n tdeps = self.fortran_deps[target.get_basename()]\\n srcdir = Path(self.source_dir)\\n\\n mod_files = _scan_fortran_file_deps(src, srcdir, dirname, tdeps, compiler)\\n return mod_files\",\n \"def _parseDependDotMake( targetBuildDir, platformBuildDir ):\\n Any.requireIsTextNonEmpty( targetBuildDir )\\n Any.requireIsTextNonEmpty( platformBuildDir )\\n\\n dependDotMakePath = os.path.join( targetBuildDir, 'depend.make' )\\n\\n lines = FastScript.getFileContent( dependDotMakePath, splitLines=True )\\n result = collections.defaultdict( set )\\n\\n languageNormalizationMap = {\\n '.c' : 'c',\\n '.C' : 'c++',\\n '.CC' : 'c++',\\n '.CPP': 'c++',\\n '.CXX': 'c++',\\n '.cc' : 'c++',\\n '.cpp': 'c++',\\n '.cxx': 'c++',\\n }\\n\\n for l in lines:\\n # skip comments and empty lines\\n if Any.isTextNonEmpty( l ) and not l.startswith( '#' ):\\n # lines are in the format\\n # /path/to/obj/file.{c,cpp,cc,cxx}.o: /path/to/dependencyfile.{c,cpp,cc,cxx,h,hpp,hxx,hh}\\n objFile, depFile = l.split( ':' )\\n srcFile, objExt = os.path.splitext( objFile.strip( ) )\\n srcName, srcExt = os.path.splitext( srcFile )\\n depFile = depFile.strip( )\\n _, depFileExt = os.path.splitext( depFile )\\n language = languageNormalizationMap[ srcExt ]\\n\\n if depFileExt.lower( ) in ('.h', '.hxx', '.hpp', '.hh'):\\n if not os.path.isabs( depFile ):\\n relPath = os.path.join( platformBuildDir, depFile )\\n absPath = os.path.abspath( relPath )\\n else:\\n absPath = depFile\\n result[ absPath ].add( language )\\n\\n\\n return result\",\n \"def rl_file_deps(file_deps, launch_file, verbose=False):\\n parse_launch(launch_file, file_deps, verbose)\",\n \"def main(path):\\n try:\\n print(\\\"Finding imports in '\\\" + path + \\\"':----------------------------------------------------------------------\\\")\\n\\n file = open(path)\\n contents = file.read()\\n wordArray = re.split(\\\" |\\\\n\\\", contents)\\n\\n currentList = list()\\n nextPaths = list()\\n skipWord = -1\\n\\n for wordNumb in range(len(wordArray)):\\n word = wordArray[wordNumb]\\n\\n if wordNumb == skipWord:\\n continue\\n\\n elif word == \\\"from\\\":\\n item = wordArray[wordNumb + 1]\\n if 'vespa.' in item:\\n currentList.append(item)\\n skipWord = wordNumb + 2\\n\\n elif word == \\\"import\\\":\\n item = wordArray[wordNumb + 1]\\n if 'vespa.' in item:\\n currentList.append(item)\\n\\n currentList = set(currentList)\\n for i in currentList:\\n print(i)\\n\\n # print(\\\"Found imports in '\\\" + path + \\\"'\\\")\\n # print(\\\"Finding paths for imports in '\\\" + path + \\\"':\\\")\\n\\n currentList2 = currentList.copy()\\n currentList = list()\\n\\n for i in currentList2:\\n if i in dependenciesNames:\\n # print(i, \\\"already found\\\")\\n pass\\n\\n else:\\n dependenciesNames.append(i)\\n\\n try:\\n fileInfo = importlib.machinery.PathFinder().find_spec(i)\\n if fileInfo is None:\\n fileInfo = importlib.util.find_spec(i)\\n if fileInfo is None:\\n origin = 'None'\\n else:\\n origin = fileInfo.origin\\n else:\\n origin = fileInfo.origin\\n\\n print(origin)\\n dependenciesPaths.append(origin)\\n currentList.append(origin)\\n\\n except AttributeError as e:\\n print(\\\"Hit Exception: AttributeError\\\")\\n print(e)\\n print(i)\\n print(importlib.machinery.PathFinder().find_spec(i))\\n # print(red, \\\"Odd noneType import called \\\", i, \\\" in path \\\", path, end, sep='')\\n\\n\\n# print(\\\"Found paths for imports in '\\\" + path + \\\"'\\\")\\n\\n\\n for fileInfo in currentList:\\n main(fileInfo)\\n\\n except Exception as e:\\n print(e)\",\n \"def scan_docs():\\n\\n\\n def scan_file(fn):\\n f = open(fn)\\n\\n for l in f:\\n m = re.search(r\\\"\\\\.\\\\. (\\\\w+):: ([.\\\\w+]+)\\\", l)\\n\\n if not m:\\n continue\\n\\n name_kind[m.group(2)] = m.group(1)\\n\\n for i in os.listdir(\\\"source\\\"):\\n if i.endswith(\\\".rst\\\"):\\n scan_file(os.path.join(\\\"source\\\", i))\\n\\n for i in os.listdir(\\\"source/inc\\\"):\\n scan_file(os.path.join(\\\"source\\\", \\\"inc\\\", i))\",\n \"def read_deps():\\n with open(\\\"./dependencies.txt\\\", 'r') as deps:\\n return [d for d in re.split(r'\\\\s', ''.join(deps)) if d]\",\n \"def find_define_file_uses(self):\\n # Executing git grep is substantially faster than using the define_re\\n # directly on the contents of the file in Python.\\n for define_file in self.get_checked_define_files():\\n excluded_files = set([define_file])\\n excluded_files.update(define_file.get_included_files(recursive=True))\\n all_defines = define_file.get_declared_defines()\\n args = ['git', 'grep', '-zwIF']\\n for define in all_defines:\\n args.extend(['-e', define])\\n args.extend(['--', '*.cpp', '*.c', '*.cu', '*.h', '*.cuh'])\\n define_re = r'\\\\b(?:' + '|'.join(all_defines)+ r')\\\\b'\\n output = subprocess.check_output(args, cwd=self._source_root).decode()\\n for line in output.splitlines():\\n (filename, text) = line.split('\\\\0')\\n fileobj = self._files.get(filename)\\n if fileobj is not None and fileobj not in excluded_files:\\n defines = re.findall(define_re, text)\\n fileobj.add_used_defines(define_file, defines)\",\n \"def add_file_dependency(self, file_name=None):\\n # self.logger.debug(\\\"add_file_dependency({0})\\\".format(file_name))\\n\\n if not isinstance(file_name, str):\\n raise TypeError\\n\\n if not os.path.exists(file_name):\\n raise FileNotFoundError(\\n \\\"module_dependency: file({}) doesn't exist.\\\".format(file_name))\\n\\n if not os.path.isfile(file_name):\\n raise FileNotFoundError(\\n \\\"module_dependency: file({}) doesn't exist.\\\".format(file_name))\\n\\n value = os.path.splitext(file_name)\\n # should be like ('network\\\\\\\\tcp_echo\\\\\\\\tcp_echo', '.py') or\\n # ('network\\\\\\\\tcp_echo', '')\\n # self.logger.debug(\\\"value({})\\\".format(value))\\n if value[1] != \\\".py\\\":\\n # self.logger.debug(\\n # \\\"module_dependency: file({}) is not PYTHON (.py)normal file.\\\")\\n return None\\n\\n # at this point, the file should be a .PY file at least\\n file_han = open(file_name)\\n for line in file_han:\\n offset = line.find(\\\"import\\\")\\n if offset >= 0:\\n # then we found a line\\n tokens = line.split()\\n\\n if len(tokens) >= 2 and tokens[0] == \\\"import\\\":\\n # then like \\\"import os.path\\\" or \\\"import os, sys, socket\\\"\\n\\n if tokens[1][-1] != \\\",\\\":\\n # then is like \\\"import os.path\\\"\\n self.logger.debug(\\\"add_file_dep:{}\\\".format(tokens[1]))\\n self.add_if_new(tokens[1])\\n\\n else: # like \\\"import os, sys, socket\\\"\\n for name in tokens[1:]:\\n self.logger.debug(\\\"token({})\\\".format(name))\\n if name[-1] == ',':\\n value = name[:-1]\\n else:\\n value = name\\n self.add_if_new(value)\\n\\n elif len(tokens) >= 4 and tokens[0] == \\\"from\\\" and \\\\\\n tokens[2] == \\\"import\\\":\\n # then is like \\\"from cp_lib.cp_self.logger import\\n # get_recommended_logger\\\"\\n self.add_if_new(tokens[1])\\n\\n file_han.close()\\n\\n # self.logger.debug(\\\"module_dependency: {}\\\".format(self.dep_list))\\n return self.dep_list\",\n \"def scan_files(self, only_files=None, keep_contents=False):\\n if only_files:\\n filelist = only_files\\n else:\\n filelist = self._files.values()\\n define_files = list(self.get_checked_define_files())\\n for define_file in list(define_files):\\n if isinstance(define_file, GeneratedFile) and \\\\\\n define_file.get_generator_source() is not None:\\n define_files.append(define_file.get_generator_source())\\n for fileobj in filelist:\\n if not fileobj.is_external():\\n detect_defines = fileobj in define_files\\n fileobj.scan_contents(self, keep_contents, detect_defines)\\n module = fileobj.get_module()\\n if module:\\n for includedfile in fileobj.get_includes():\\n otherfile = includedfile.get_file()\\n if otherfile:\\n othermodule = otherfile.get_module()\\n if othermodule and othermodule != module:\\n module.add_dependency(othermodule, includedfile)\",\n \"def find_with_deps(self, package_names):\",\n \"def scan(\\n cli_call_name: str, module: str, package: Optional[str], verbose: bool, help: Optional[str]\\n) -> CommandTrie:\\n root_module = importlib.import_module(module, package=package)\\n root_path = root_module.__file__\\n\\n if verbose:\\n print(\\\"Scanning module {} starting at file path: {}\\\".format(module, root_path))\\n\\n # Format the module name correctly if this is a relative import we're starting with\\n target_module = module\\n if _is_relative(target_module):\\n if package is None:\\n raise CommandError(\\\"Package was not specified but the module is relative.\\\")\\n\\n target_module = package\\n\\n # Search path changes if the __file__ entry is a python init file and not a directory\\n search_path = root_path\\n if search_path.endswith(_PYTHON_MODULE_INIT_FILE):\\n search_path = os.path.dirname(root_path)\\n\\n # First identify all submodules\\n submodule_names = list()\\n\\n # If our search path is not a directory, move on\\n if os.path.isdir(search_path):\\n for filename in os.listdir(search_path):\\n if filename in _IGNORE_LIST:\\n continue\\n\\n abs_path = os.path.join(search_path, filename)\\n init_path = os.path.join(abs_path, _PYTHON_MODULE_INIT_FILE)\\n\\n module_name = \\\"\\\"\\n if os.path.isdir(abs_path) and os.path.exists(init_path):\\n # Figure out if we're dealing with a directory that has the init file\\n module_name = \\\".\\\".join((target_module, filename))\\n elif _is_python_src_file(filename):\\n # Is it a python source file that's stand-alone?\\n file_module_name = os.path.splitext(filename)[0]\\n module_name = \\\".\\\".join((target_module, file_module_name))\\n else:\\n # I don't like this continue but avoiding the print statement twice is a nice consequence\\n continue\\n\\n if verbose:\\n print(\\\"Adding module {} to the scan list.\\\".format(module_name))\\n\\n # Add the module to our scan and import list\\n submodule_names.append(module_name)\\n\\n # Load the modules\\n submodules = [importlib.import_module(n) for n in submodule_names]\\n\\n # Add the root module since that's part of the scan\\n submodules.append(root_module)\\n\\n # Load and scan the submodules for command components\\n command_components = list()\\n for submodule in submodules:\\n for component_name in dir(submodule):\\n component = getattr(submodule, component_name)\\n if isinstance(component, CommandWrapper):\\n if verbose:\\n print(\\\"Found command component: {}\\\".format(component))\\n\\n command_components.append(component)\\n\\n # Build our command trie with collected components and perform rudimentary\\n # dependency resolution for command paths\\n command_trie = CommandTrie(cli_call_name, help=help)\\n while len(command_components) > 0:\\n delete_list = list()\\n for idx in range(0, len(command_components)):\\n command = command_components[idx]\\n\\n if command_trie.insert(command) is True:\\n if verbose:\\n print(\\\"Inserted {}\\\".format(command))\\n\\n delete_list.append(idx)\\n break\\n\\n if len(delete_list) == 0:\\n raise CommandDependencyError(\\\"Dependency resolution error!\\\")\\n\\n for idx in reversed(sorted(delete_list)):\\n command_components.pop(idx)\\n\\n return command_trie\",\n \"def PrepareCompile(file):\\n global oilcc_I,oilcc_o,oilcc_S,oilcc_target\\n fp = open(file,'r')\\n # some flags\\n item = ''; #one item is minimum object such as TASK,ALARM ...\\n barcenum = 0;\\n flag = False; #has \\\" { \\\" encountered or not\\n start = False #has match an obj start or not\\n for line in fp.readlines():\\n #firstly, filter out the comment on this line\\n el = DropComment(line);\\n if(start == False):\\n #{\\n item = ''; \\n barcenum = 0;\\n flag = False;\\n if(IsIt('osekObj',el)):\\n start = True;\\n item += el;\\n if(el.count('{') > 0): #so at comment should not include '{}'\\n flag = True;\\n barcenum += el.count('{');\\n if(el.count('}') > 0):\\n barcenum -= el.count('}');\\n if((flag == True) and (barcenum == 0)): #in one line\\n #filter out the multi-line comment\\n item = DropComment(item)\\n oilcc_texts.append(item);\\n start = False\\n else: # special process for include\\n inc = GetIt('include',el)\\n if(inc != None): #include file\\n flag_inc = False\\n for I in oilcc_I:\\n finc = I + '/' + inc[0]\\n if(os.path.exists(finc)):\\n print 'INFO:parse include file <%s> in the path <%s>'%(inc[0],I)\\n PrepareCompile(finc);\\n flag_inc = True;\\n if(flag_inc == False):\\n print 'ERROR:cann\\\\'t find out the file %s!'%(inc[0])\\n sys.exit(-1)\\n #}\\n else:\\n #{\\n if(el.count('{') > 0): #so at comment should not include '{}'\\n flag = True;\\n barcenum += el.count('{');\\n if(el.count('}') > 0):\\n barcenum -= el.count('}');\\n item += el;\\n if((flag == True) and (barcenum == 0)):\\n #filter out the multi-line comment\\n item = DropComment(item)\\n oilcc_texts.append(item);\\n start = False\\n #}\\n fp.close()\",\n \"def _get_include_files(self):\\n for dirpath, dirnames, filenames in os.walk(self.IncludesDirectory):\\n for f in filenames:\\n rel_name = path.join(dirpath, f)\\n if f.endswith('.pyx'):\\n yield (rel_name, 'PyRex')\\n elif f.endswith('.h'):\\n yield (rel_name, 'Header')\\n else:\\n pass\",\n \"def _resolve_required_macros(file_content):\\n call_commands = \\\"\\\"\\n for line in file_content.split(\\\"\\\\n\\\"):\\n match = re.search(\\\"^!@require\\\\s+([^\\\\s]+).*$\\\", line)\\n if match is not None:\\n required_macros = _add_macro_lib_ending(match.group(1))\\n required_macros_file = abspath(join(LIB, required_macros))\\n call_commands += _resolve_required_macros(_read_input_file(required_macros_file))\\n call_commands += \\\"call, file = \\\\\\\"\\\" + required_macros_file + \\\"\\\\\\\";\\\\n\\\"\\n return call_commands\",\n \"def Load():\\n global items, libraries, _line_number, _groups_to_be_defined\\n deps_file = open(\\\"dependencies.txt\\\")\\n try:\\n line = None\\n current_type = None\\n while True:\\n while not line: line = _RemoveComment(deps_file.next())\\n\\n if line.startswith(\\\"library: \\\"):\\n current_type = \\\"library\\\"\\n name = line[9:].lstrip()\\n _CheckLibraryName(name)\\n if name in items:\\n sys.exit(\\\"Error:%d: library definition using duplicate name %s\\\" % (_line_number, name))\\n libraries.add(name)\\n item = items[name] = {\\\"type\\\": \\\"library\\\", \\\"name\\\": name}\\n line = _ReadFiles(deps_file, item, name)\\n elif line.startswith(\\\"group: \\\"):\\n current_type = \\\"group\\\"\\n name = line[7:].lstrip()\\n _CheckGroupName(name)\\n if name not in items:\\n sys.exit(\\\"Error:%d: group %s defined before mentioned as a dependency\\\" %\\n (_line_number, name))\\n if name not in _groups_to_be_defined:\\n sys.exit(\\\"Error:%d: group definition using duplicate name %s\\\" % (_line_number, name))\\n _groups_to_be_defined.remove(name)\\n item = items[name]\\n item[\\\"name\\\"] = name\\n library_name = item.get(\\\"library\\\")\\n if library_name:\\n line = _ReadFiles(deps_file, item, library_name)\\n else:\\n line = _ReadSystemSymbols(deps_file, item)\\n elif line == \\\" deps\\\":\\n if current_type == \\\"library\\\":\\n line = _ReadDeps(deps_file, items[name], name)\\n elif current_type == \\\"group\\\":\\n item = items[name]\\n line = _ReadDeps(deps_file, item, item.get(\\\"library\\\"))\\n elif current_type == \\\"system_symbols\\\":\\n item = items[current_type]\\n line = _ReadDeps(deps_file, item, None)\\n else:\\n sys.exit(\\\"Error:%d: deps before any library or group\\\" % _line_number)\\n elif line == \\\"system_symbols:\\\":\\n current_type = \\\"system_symbols\\\"\\n if current_type in items:\\n sys.exit(\\\"Error:%d: duplicate entry for system_symbols\\\" % _line_number)\\n item = items[current_type] = {\\\"type\\\": current_type, \\\"name\\\": current_type}\\n line = _ReadSystemSymbols(deps_file, item)\\n else:\\n sys.exit(\\\"Syntax error:%d: %s\\\" % (_line_number, line))\\n except StopIteration:\\n pass\\n if _groups_to_be_defined:\\n sys.exit(\\\"Error: some groups mentioned in dependencies are undefined: %s\\\" % _groups_to_be_defined)\",\n \"def read_dependencies(filename):\\n\\n dependencies = []\\n with open(filename) as f:\\n for line in f.readlines():\\n if not line or line.startswith('#'):\\n continue\\n dependencies.append(line.strip())\\n return dependencies\",\n \"def get_docs( mysource , basename ):\\n import parser\\n ast = parser.suite(mysource)\\n return ModuleInfo(ast.totuple(1), basename)\",\n \"def pre_process(in_path):\\n in_string = open(in_path, 'r').read()\\n multi_line = '/\\\\\\\\*[^*]*\\\\\\\\*+(?:[^/*][^*]*\\\\\\\\*+)*/'\\n\\n # header\\n description = re.search(multi_line, in_string).group(0)\\n unit = re.search('\\\\\\\\n\\\\\\\\s*// unit .*', in_string).group(0)\\n imports = re.findall('\\\\\\\\n\\\\\\\\s*// import .*', in_string)\\n import_string = ''\\n for i in imports:\\n import_string += resolve_import(i.strip()[10:], in_path.parent)\\n\\n use_string = ''\\n uses = re.findall('\\\\\\\\n\\\\\\\\s*// uses .*', in_string)\\n for u in uses:\\n use_string += 'uses ' + u.strip()[8:] + ';\\\\n'\\n if use_string != '':\\n use_string = '\\\\n\\\\n' + use_string\\n\\n header = '{' + description[2:-2] + '}\\\\n\\\\nunit ' + unit.strip()[8:] + ';' + use_string + '\\\\n\\\\n'\\n\\n # main part\\n in_string_list, delphi_string_list = split(import_string + '\\\\n\\\\n' + in_string)\\n\\n return header, in_string_list, delphi_string_list\",\n \"def test_scan_and_find_dependencies_golang():\\n manifests = [{\\n \\\"filename\\\": \\\"golist.json\\\",\\n \\\"filepath\\\": \\\"/bin/local\\\",\\n \\\"content\\\": open(str(Path(__file__).parent / \\\"data/manifests/gograph.txt\\\")).read()\\n }]\\n res = DependencyFinder().scan_and_find_dependencies(\\\"golang\\\", manifests, \\\"true\\\")\\n assert \\\"result\\\" in res\\n assert res['result'][0]['details'][0]['_resolved'][0]['package'] == \\\\\\n \\\"github.com/go-logr/logr\\\"\",\n \"def main():\\n if len(sys.argv) == 1:\\n print(\\\"No dependencies file to validate!\\\")\\n return\\n dependencies_file = sys.argv[1]\\n try:\\n dependencies = json.loads(open(dependencies_file, 'r').read())\\n except json.decoder.JSONDecodeError:\\n print(\\\"Invalid dependency file syntax! Make sure you don't have any commas at the end of your last dependency.\\\")\\n return\\n for dependency in dependencies:\\n if 'target_path' in dependency and 'repository' in dependency:\\n print(\\\"Validated {}\\\".format(dependency['target_path']))\\n suggest_edits(dependency)\\n elif 'target_path' not in dependency and 'repository' in dependency:\\n print(\\\"Define target_path for dependency {}\\\".format(dependency['repository']))\\n elif 'repository' not in dependency and 'target_path' in dependency:\\n print(\\\"Define repository for dependency {}\\\".format(dependency['target_path']))\\n else:\\n print(\\\"Invalid format, missing repository and target_path for dependency {}\\\".format(dependencies.index(dependency)))\",\n \"def _scan_bytecode(\\n self, module, module_code_object, is_scanning_imports):\\n level = None\\n fromlist = None\\n\\n # 'deque' is a list-like container with fast appends, pops on\\n # either end, and automatically discarding elements too much.\\n prev_insts = deque(maxlen=2)\\n for inst in util.iterate_instructions(module_code_object):\\n if not inst:\\n continue\\n # If this is an import statement originating from this module,\\n # parse this import.\\n #\\n # Note that the related \\\"IMPORT_FROM\\\" opcode need *NOT* be parsed.\\n # \\\"IMPORT_NAME\\\" suffices. For further details, see\\n # http://probablyprogramming.com/2008/04/14/python-import_name\\n if inst.opname == 'IMPORT_NAME':\\n # If this method is ignoring import statements, skip to the\\n # next opcode.\\n if not is_scanning_imports:\\n continue\\n\\n assert prev_insts[-2].opname == 'LOAD_CONST'\\n assert prev_insts[-1].opname == 'LOAD_CONST'\\n\\n # Python >=2.5: LOAD_CONST flags, LOAD_CONST names, IMPORT_NAME name\\n level = prev_insts[-2].argval\\n fromlist = prev_insts[-1].argval\\n\\n assert fromlist is None or type(fromlist) is tuple\\n target_module_partname = inst.argval\\n\\n #FIXME: The exact same logic appears in _collect_import(),\\n #which isn't particularly helpful. Instead, defer this logic\\n #until later by:\\n #\\n #* Refactor the \\\"_deferred_imports\\\" list to contain 2-tuples\\n # \\\"(_safe_import_hook_args, _safe_import_hook_kwargs)\\\" rather\\n # than 3-tuples \\\"(have_star, _safe_import_hook_args,\\n # _safe_import_hook_kwargs)\\\".\\n #* Stop prepending these tuples by a \\\"have_star\\\" boolean both\\n # here, in _collect_import(), and in _process_imports().\\n #* Shift the logic below to _process_imports().\\n #* Remove the same logic from _collect_import().\\n have_star = False\\n if fromlist is not None:\\n fromlist = uniq(fromlist)\\n if '*' in fromlist:\\n fromlist.remove('*')\\n have_star = True\\n\\n # Record this import as originating from this module for\\n # subsequent handling by the _process_imports() method.\\n module._deferred_imports.append((\\n have_star,\\n (target_module_partname, module, fromlist, level),\\n {}\\n ))\\n\\n elif inst.opname in ('STORE_NAME', 'STORE_GLOBAL'):\\n # If this is the declaration of a global attribute (e.g.,\\n # class, variable) in this module, store this declaration for\\n # subsequent lookup. See method docstring for further details.\\n #\\n # Global attributes are usually irrelevant to import parsing, but\\n # remain the only means of distinguishing erroneous non-ignorable\\n # attempts to import non-existent submodules of a package from\\n # successful ignorable attempts to import existing global\\n # attributes of a package's \\\"__init__\\\" submodule (e.g., the \\\"bar\\\"\\n # in \\\"from foo import bar\\\", which is either a non-ignorable\\n # submodule of \\\"foo\\\" or an ignorable global attribute of\\n # \\\"foo.__init__\\\").\\n name = inst.argval\\n module.add_global_attr(name)\\n\\n elif inst.opname in ('DELETE_NAME', 'DELETE_GLOBAL'):\\n # If this is the undeclaration of a previously declared global\\n # attribute (e.g., class, variable) in this module, remove that\\n # declaration to prevent subsequent lookup. See method docstring\\n # for further details.\\n name = inst.argval\\n module.remove_global_attr_if_found(name)\\n\\n prev_insts.append(inst)\",\n \"def required_files(self, args):\\n args_set = set(args)\\n edge_list = self.__transform_pre(self.__include_deps_supply.get_file_include_deps())\\n targets = chain((target for (source, target) in edge_list if source in args_set), args_set)\\n return self.__transform_post(targets)\",\n \"def get_deps(cat, pkg, ns, rpkgs):\\n with (settings.RAINBOARD_RPKG / cat / pkg / \\\"Makefile\\\").open() as file_handle:\\n cont = file_handle.read()\\n deps = [\\n d_pkg\\n for d_cat, d_pkg, _ in rpkgs\\n if f\\\"\\\\ninclude ../../{d_cat}/{d_pkg}/depend.mk\\\\n\\\" in cont\\n ]\\n if pkg.startswith(\\\"py-\\\") and (cat, pkg[3:], ns) in rpkgs:\\n deps.append(pkg[3:])\\n deps_cache[pkg] = sorted(set(deps))\\n return deps_cache[pkg]\",\n \"def gather_required_files(filename):\\n # open the file, while ignoring encoding errors (usually comments)\\n encoding = open_guess_encoding(filename)\\n with open(filename, encoding=encoding, errors='surrogateescape') as fp:\\n config = MugenParser()\\n config.read_string(fp.read())\\n\\n # go through each section and store any options that look like filenames\\n required = set()\\n for section in config.sections():\\n section = config[section]\\n options = set(find_asset(normpath(v)) for k, v in section.items()\\n if filename_regex.match(v))\\n required.update(options)\\n\\n # check other def files, then search them and add the results\\n root = dirname(filename)\\n for child_file in required.copy():\\n name, ext = os.path.splitext(child_file)\\n if ext.lower() == '.def':\\n path = join(root, child_file)\\n required.update(gather_required_files(path))\\n\\n # TODO: this is not implemented\\n # mugen does checking against many paths, so we need\\n # to emulate that the if we want to check for missing files\\n # finally, go through the potential files and verify they exist\\n # for child_file in required.copy():\\n # path = join(root, child_file)\\n # if not os.path.exists(path):\\n # required.remove(child_file)\\n\\n return required\",\n \"def generate_dependencies(data, mib_name):\\r\\n if mib_name not in mib_dependency_map:\\r\\n mib_dependency_map[mib_name] = []\\r\\n imports_section_search = re.search('IMPORTS(?P<imports_section>.*?);', data, re.DOTALL)\\r\\n if imports_section_search:\\r\\n imports_section = imports_section_search.group('imports_section')\\r\\n for dependency in re.finditer('FROM (?P<mib_name>[\\\\w-]+)', imports_section):\\r\\n dependency_name = dependency.group('mib_name')\\r\\n if dependency_name not in mib_dependency_map:\\r\\n mib_dependency_map[dependency_name] = []\\r\\n mib_dependency_map[mib_name].append(dependency_name)\",\n \"def find_extra_include(file_name):\\r\\n extra_includes = []\\r\\n with open(file_name) as f:\\r\\n for m in re.finditer(regex.extra_include, f.read()):\\r\\n extra_includes.append(m.groups(1))\\r\\n return extra_includes\",\n \"def define_regex(module_names=modules, doc_types=types, exts=exts):\\n letters = ''\\n module_codes = ''\\n file_exts = ''\\n # Populate code letter String\\n for letter in doc_types:\\n letters += letter\\n # Populate extension string\\n for ext in exts:\\n if ext != exts[-1]:\\n file_exts += f\\\"{ext}|\\\"\\n else:\\n file_exts += ext\\n # Populate modules string\\n for module in modules:\\n if module != modules[-1]:\\n module_codes += f\\\"{module}|\\\"\\n else:\\n module_codes += module\\n regex = r\\\"(\\\" + module_codes + \\\"){1}[\\\" + letters + \\\"]{1}\\\\_[^.]*\\\\.(\\\" + file_exts + \\\")\\\" \\n return regex\",\n \"def _verify_include_files_used(self, file_uses, included_files):\\n for include_file, use in file_uses.items():\\n if not use & USES_DECLARATION:\\n node, module = included_files[include_file]\\n if module.ast_list is not None:\\n msg = \\\"'{}' does not need to be #included\\\".format(\\n node.filename)\\n if use & USES_REFERENCE:\\n msg += '; use a forward declaration instead'\\n self._add_warning(msg, node)\",\n \"def find_dependencies(root):\\n \\n symbol_table = create_symbol_table(root)\\n\\n names = []\\n #Set the depth of the root node\\n set_depth(root, 0)\\n #Stack of nodes to visit\\n stack = Stack(root)\\n \\n #List of (src, dest) of dependencies\\n dependency_table = DTable(symbol_table=symbol_table)\\n\\n for node, children, ntype in stack:\\n \\n stack.check_and_push_scope()\\n\\n #A Name is being loaded, therefore \\n if ntype == \\\"Name\\\" and is_load(children):\\n \\\"\\\"\\\"\\n \\\"\\\"\\\"\\n dependency_table.append( (stack.scopes, node))\\n \\n elif ntype == \\\"Assign\\\":\\n #TODO need to add assignments and then revoke them\\n #for child in children:\\n #print children\\n pass\\n\\n \\n elif ntype == \\\"Attribute\\\":\\n #TODO: attribute chains can be arbitrarily long\\n #dep_dest = \\\"{}.{}\\\".format(node.value.id, node.attr)\\n #print \\\"{} => {}\\\".format(scopes_to_str(scopes), dep_dest)\\n\\n #TODO: Can't just do dependency_table.append( (scopes, node))\\n #since the unique_id function won't match the create the dep string like \\n #{node.value.id}.{node.attr}.\\n #Either generalize unique_id or something else.\\n \\n #Don't add children\\n continue\\n \\n set_lineno(node, children)\\n #Add children to stack\\n #This musn't always be performed\\n for child in children[::-1]:\\n set_depth(child, node.depth + 1)\\n stack.append(child)\\n\\n print \\\"dependency table is \\\"\\n print dependency_table\",\n \"def get_dependencies(path):\\n dependencies_path = os.path.join(path, \\\"dependencies.txt\\\")\\n dependencies_pattern = r\\\"([a-z]+(?:[_-][a-z]+)*)(.=)+(([1-9][0-9]*!)?(0|[1-9][0-9]*)(\\\\.(0|[1-9][0-9]*))*((a|b|rc)(0|[1-9][0-9]*))?(\\\\.post(0|[1-9][0-9]*))?(\\\\.dev(0|[1-9][0-9]*))?)\\\"\\n \\\"\\\"\\\"\\n Example:\\n input: iobeam==0.7.15\\n mrb-hw-info==0.0.25\\n mrbeam-ledstrips==0.2.2-alpha.2\\n output: [[iobeam][==][0.7.15]]\\n [[mrb-hw-info][==][0.0.25]]\\n [[mrbeam-ledstrips][==][0.2.2-alpha.2]]\\n \\\"\\\"\\\"\\n try:\\n with open(dependencies_path, \\\"r\\\") as f:\\n dependencies_content = f.read()\\n dependencies = re.findall(dependencies_pattern, dependencies_content)\\n dependencies = [{\\\"name\\\": dep[0], \\\"version\\\": dep[2]} for dep in dependencies]\\n except IOError:\\n raise RuntimeError(\\\"Could not load dependencies\\\")\\n return dependencies\",\n \"def extract_deps(self, srcinfo):\\n packages = {}\\n pkgname = \\\"\\\"\\n\\n for i in srcinfo.split(\\\"\\\\n\\\"):\\n if not i:\\n continue\\n if i[0] == \\\"#\\\":\\n continue\\n option = i.strip()\\n key, value = option.split(\\\" = \\\")\\n if key == \\\"pkgbase\\\":\\n pkgname = value\\n packages[pkgname] = []\\n if key == \\\"makedepends\\\":\\n packages[pkgname].append(value)\\n # if key == \\\"depends\\\":\\n # packages[pkgname].append(value)\\n return packages\",\n \"def includeme(root):\\n configure.scan(\\\"backend.services\\\")\\n configure.scan(\\\"backend.content\\\")\\n configure.scan(\\\"backend.install\\\")\",\n \"def find_modules(x):\\n return Path(x).rglob('*.py')\",\n \"def __get_compile_cache_dep_files(file_path, compile_cache_dep_files, pkg):\\n with open(file_path) as fh:\\n root = ast.parse(fh.read(), file_path)\\n for node in ast.iter_child_nodes(root):\\n module_name = \\\"\\\"\\n if isinstance(node, ast.ImportFrom):\\n if node.module is not None:\\n module_name = node.module\\n if node.level == 1:\\n module_name = \\\".\\\" + module_name\\n elif not isinstance(node, ast.Import):\\n continue\\n # Do not care the files in mindspore package\\n if module_name.startswith(\\\"mindspore\\\"):\\n continue\\n\\n for n in node.names:\\n if n.name.startswith(\\\"mindspore\\\"):\\n continue\\n if module_name == \\\"\\\":\\n whole_module = n.name\\n else:\\n whole_module = module_name\\n if n.name is not None:\\n whole_module += \\\".\\\" + n.name\\n try:\\n module_spec = importlib.util.find_spec(whole_module, pkg)\\n except (ModuleNotFoundError, ValueError):\\n whole_module = whole_module[0:whole_module.rfind('.')]\\n module_spec = importlib.util.find_spec(whole_module, pkg)\\n if module_spec is None:\\n continue\\n module = importlib.util.module_from_spec(module_spec)\\n if hasattr(module, '__file__'):\\n dep_file_path = module.__file__\\n else:\\n continue\\n # Exclude the installed modules.\\n if not _in_sys_path(dep_file_path) and dep_file_path not in compile_cache_dep_files:\\n logger.debug(f\\\"dependent file path: {dep_file_path}\\\")\\n compile_cache_dep_files.append(dep_file_path)\\n __get_compile_cache_dep_files(dep_file_path, compile_cache_dep_files, module.__package__)\",\n \"def find_reference_files():\\n for root, _, files in os.walk(\\\"./tests/references/\\\"):\\n for basename in fnmatch.filter(files, \\\"*.tex\\\"):\\n yield os.path.join(root, basename)\",\n \"def scan_source(filename, def_re = None, cb = (lambda l,m : None) ) :\\n import re\\n\\n if not def_re :\\n storage_class = br\\\"(static\\\\s+)?\\\"\\n type_and_name = br\\\"int\\\\s+(?P<n>test_[_a-zA-Z0-9]*)\\\";\\n args=br\\\"\\\\(.*\\\\)\\\";\\n def_re = re.compile(b\\\"\\\\s*\\\" + storage_class +\\n type_and_name + b\\\"\\\\s*\\\" +\\n args );\\n\\n tests = set()\\n with open(filename, \\\"rb\\\") as f:\\n for line in f:\\n m = def_re.match(line)\\n if not m : continue\\n cb(line, m)\\n tests.add( m.group('n').strip().decode('utf-8') )\\n return tests\",\n \"def __compute_dependencies(self):\\n prefix = \\\"github.com/DataDog/datadog-agent/\\\"\\n base_path = os.getcwd()\\n mod_parser_path = os.path.join(base_path, \\\"internal\\\", \\\"tools\\\", \\\"modparser\\\")\\n\\n if not os.path.isdir(mod_parser_path):\\n raise Exception(f\\\"Cannot find go.mod parser in {mod_parser_path}\\\")\\n\\n try:\\n output = subprocess.check_output(\\n [\\\"go\\\", \\\"run\\\", \\\".\\\", \\\"-path\\\", os.path.join(base_path, self.path), \\\"-prefix\\\", prefix],\\n cwd=mod_parser_path,\\n ).decode(\\\"utf-8\\\")\\n except subprocess.CalledProcessError as e:\\n print(f\\\"Error while calling go.mod parser: {e.output}\\\")\\n raise e\\n\\n # Remove github.com/DataDog/datadog-agent/ from each line\\n return [line[len(prefix) :] for line in output.strip().splitlines()]\",\n \"def getRefs(self):\\n\\n backend = self.backend\\n refs = self.moduleRefs\\n for ref in refs:\\n refPure = ref.rsplit(\\\":\\\", 1)[0]\\n if refPure in self.seen:\\n continue\\n\\n parts = splitModRef(ref)\\n if not parts:\\n self.good = False\\n continue\\n\\n parts[2] = prefixSlash(normpath(parts[2])) # the relative bit\\n theBackend = (\\n None if parts[-1] is None or parts[-1] == backend else parts[-1]\\n )\\n\\n if not self.getModule(*parts[0:-1], backend=theBackend):\\n self.good = False\",\n \"def search(self, src, exclude_pattern = [\\\"**/*.pyc\\\"], include_pattern = [\\\"**/*.py\\\"]):\\n src = os.path.abspath(src)\\n \\n _target = Path(src)\\n _target._flavour.casefold = lambda x : x # basic windows path don't distinguish upper / lower case.\\n allfiles = list(_target.glob(\\\"**/*\\\"))\\n \\n exclude = list()\\n for _ex in exclude_pattern:\\n exclude += _target.glob(_ex) \\n \\n include = list()\\n for _in in include_pattern:\\n include += _target.glob(_in) \\n \\n _target_path = set(allfiles) - set(exclude) | set(include)\\n \\n _target_dir_path = sorted(list(x for x in _target_path if x.is_dir() is True))\\n _target_file_path = sorted(list(x for x in _target_path if x.is_file() is True))\\n \\n return _target_dir_path, _target_file_path\",\n \"def checkAllFilesIncluded(self):\\n # TODO: config objects: this import can go away\\n from exhale.configs import unabridgedOrphanKinds\\n\\n # build path to unabridged api document that adds all toctree directives\\n root = get_exhale_root(self)\\n containmentFolder = self.getAbsContainmentFolder()\\n unabridged_api_path = os.path.join(containmentFolder, \\\"unabridged_api.rst.include\\\")\\n unabridged_orphan_path = os.path.join(containmentFolder, \\\"unabridged_orphan.rst\\\")\\n\\n # gather lines that match the indented part of the toctree\\n #\\n # .. toctree::\\n # :maxdepth: {toctreeMaxDepth}\\n #\\n # some_node.file_name.rst\\n #\\n # so just lazily look for the leading three spaces and ending with .rst\\n full_api_toctrees = []\\n under_toctree_re = re.compile(r\\\"^ .+\\\\.rst$\\\")\\n with open(unabridged_api_path) as unabridged_api:\\n for line in unabridged_api:\\n if under_toctree_re.match(line):\\n full_api_toctrees.append(line.strip())\\n\\n orphan_toctrees = []\\n if os.path.isfile(unabridged_orphan_path):\\n with open(unabridged_orphan_path) as unabridged_orphan:\\n for line in unabridged_orphan:\\n if under_toctree_re.match(line):\\n orphan_toctrees.append(line.strip())\\n\\n # Scan all nodes and make sure they were found in the toctrees above.\\n doxygen_mainpage_was_used = False\\n for node in root.all_nodes:\\n if node.kind in {\\\"enumvalue\\\", \\\"group\\\"}:\\n continue\\n\\n # When doxygen \\\\mainpage command is used, the .. doxygenpage:: index\\n # is .. include::'ed in the root file document. Those checks come\\n # after this loop.\\n if node.kind == \\\"page\\\" and node.refid == \\\"indexpage\\\":\\n doxygen_mainpage_was_used = True\\n continue\\n\\n if node.kind in unabridgedOrphanKinds or \\\\\\n (node.kind == \\\"class\\\" and \\\"struct\\\" in unabridgedOrphanKinds) or \\\\\\n (node.kind == \\\"struct\\\" and \\\"class\\\" in unabridgedOrphanKinds):\\n toctrees = orphan_toctrees\\n doc = unabridged_orphan_path\\n else:\\n toctrees = full_api_toctrees\\n doc = unabridged_api_path\\n\\n self.assertTrue(\\n node.file_name in toctrees,\\n \\\"Node refid=[{refid}] and basename=[{file_name}] not found in [{doc}]!\\\".format(\\n refid=node.refid, file_name=node.file_name, doc=doc\\n )\\n )\\n\\n # Make sure every document expected to be .. include::'ed in the library root\\n # has actually been included.\\n full_root_file_path = root.full_root_file_path\\n root_file_includes = []\\n with open(full_root_file_path, \\\"r\\\") as full_root_f:\\n for line in full_root_f:\\n include_mark = \\\".. include::\\\"\\n if line.startswith(include_mark):\\n root_file_includes.append(line.split(include_mark)[-1].strip())\\n\\n index_include = False # page_index.rst comes from doxygen \\\\mainpage\\n page_hierarchy_include = False # page_view_hierarchy.rst\\n class_hierarchy_include = False # class_view_hierarchy.rst\\n file_hierarchy_include = False # file_view_hierarchy.rst\\n unabridged_api_include = True # unabridged_api.rst. Always included.\\n orphan_api_include = False # unabridged_orphan.rst. Never included.\\n for node in root.all_nodes:\\n if node.kind == \\\"page\\\":\\n if node.refid == \\\"indexpage\\\":\\n index_include = True\\n else:\\n page_hierarchy_include = True\\n elif node.kind in exhale.utils.CLASS_LIKE_KINDS:\\n class_hierarchy_include = True\\n elif node.kind in {\\\"dir\\\", \\\"file\\\"}:\\n file_hierarchy_include = True\\n\\n self.assertTrue(\\n doxygen_mainpage_was_used == index_include,\\n \\\"Mismatch: doxygen_mainpage_was_used != index_include!\\\")\\n\\n include_map = {\\n \\\"page_index.rst.include\\\": index_include,\\n os.path.basename(root.page_hierarchy_file): page_hierarchy_include,\\n os.path.basename(root.class_hierarchy_file): class_hierarchy_include,\\n os.path.basename(root.file_hierarchy_file): file_hierarchy_include,\\n os.path.basename(root.unabridged_api_file): unabridged_api_include,\\n os.path.basename(root.unabridged_orphan_file): orphan_api_include\\n }\\n root_file_base = os.path.basename(full_root_file_path)\\n for key, val in include_map.items():\\n if val:\\n check = getattr(self, \\\"assertTrue\\\")\\n msg = \\\"*WAS* expected in {root_file_base}, but was *NOT* found!\\\".format(\\n root_file_base=root_file_base\\n )\\n else:\\n check = getattr(self, \\\"assertFalse\\\")\\n msg = \\\"was *NOT* expected in {root_file_base}, but *WAS* found!\\\".format(\\n root_file_base=root_file_base\\n )\\n check(\\n key in root_file_includes,\\n \\\"Page '{key}' {msg}\\\".format(key=key, msg=msg))\\n\\n # Some tests may want the toctree names afterward.\\n return full_api_toctrees, orphan_toctrees\",\n \"def _add_recurse(self, path_name, dot_name):\\n # self.logger.debug(\\n # \\\"_add_recurse({0},{1})\\\".format(path_name, dot_name))\\n\\n added_count = 0\\n if os.path.isdir(path_name):\\n # then is module, such as xmlrpc, with includes:\\n # network/tcp_echo/xmlrpc/__init__.py\\n # network/tcp_echo/xmlrpc/client.py\\n # network/tcp_echo/xmlrpc/server.py\\n self.logger.debug(\\\"Recurse into directory ({})\\\".format(path_name))\\n\\n dir_list = os.listdir(path_name)\\n for name in dir_list:\\n if name == \\\"__pycache__\\\":\\n self.logger.debug(\\n \\\" skip known skipper ({})\\\".format(name))\\n continue\\n\\n if name == \\\"test\\\":\\n self.logger.debug(\\n \\\" skip known skipper ({})\\\".format(name))\\n continue\\n\\n if name[0] == \\\".\\\":\\n self.logger.debug(\\n \\\" skip pattern skipper ({})\\\".format(name))\\n continue\\n\\n # still here, see if file or subdirectory\\n file_name = os.path.join(path_name, name)\\n if os.path.isdir(file_name):\\n # then another sub-directory\\n added_count += self._add_recurse(\\n file_name, dot_name + '.' + name)\\n\\n else: # assume is a file?\\n # for example, name=client.py\\n if name.endswith(\\\".py\\\"):\\n self.dep_list.append(file_name)\\n added_count += 1\\n try:\\n self.logger.debug(\\n \\\"Recurse into s-file ({})\\\".format(file_name))\\n self.add_file_dependency(file_name)\\n\\n except FileNotFoundError:\\n self.logger.error(\\n \\\"Could NOT find above dependency within\\\" +\\n \\\"({})\\\".format(file_name))\\n # sys.exit(EXIT_CODE_MISSING_DEP)\\n\\n else:\\n # expects network.tcp_echo.xmlrpc.something.txt\\n value = path_name + os.sep + name\\n self.logger.debug(\\n \\\"Add file as dependency({})\\\".format(value))\\n self.dep_list.append(value)\\n added_count += 1\\n\\n else:\\n # might be file, like network/tcp_echo/ftplib.py as\\n # network.tcp_echo.ftplib\\n if not path_name.endswith(\\\".py\\\"):\\n path_name += \\\".py\\\"\\n self.logger.debug(\\\"Recurse into d-file ({})\\\".format(path_name))\\n self.add_file_dependency(path_name)\\n\\n return added_count\",\n \"def check_all():\\n for name, module in sorted(sys.modules.items()): # module files\\n filepath = getattr(module, '__file__', None)\\n if filepath is None:\\n # we land here when a module is an attribute of another module\\n # i.e., it exists twice in the sys.modules table, once as its\\n # canonical representation, and again having been imported\\n # within another module\\n continue\\n filepath = filepath.endswith(\\\".pyc\\\") and filepath[:-1] or filepath\\n check_one(filepath)\\n\\n for filepath in extras: # additional files\\n check_one(filepath)\",\n \"def XXXcheck_class_dependencies(self, node):\\n # keep track of types which are used by methods arguments\\n used_types = {}\\n for method in node[\\\"methods\\\"]:\\n self.check_function_dependencies(method, used_types)\\n\\n modules = {}\\n for typ in used_types.values():\\n if typ.f_module:\\n for mname, only in typ.f_module.items():\\n module = modules.setdefault(mname, {})\\n if only: # Empty list means no ONLY clause\\n for oname in only:\\n module[oname] = True\\n\\n # Always add C_PTR, needed for class F_derived_member\\n modules.setdefault(\\\"iso_c_binding\\\", {})[\\\"C_PTR\\\"] = True\\n\\n F_modules = [] # array of tuples ( name, (only1, only2) )\\n for mname in sorted(modules):\\n F_modules.append((mname, sorted(modules[mname])))\\n node.F_module_dependencies = F_modules\",\n \"def filter_depend( self, atoms ):\\n\\n def dep_string_reduce(dep_string,enabled_useflags):\\n dest = []\\n tokens = iter(dep_string.split())\\n useflags = enabled_useflags.split()\\n\\n for token in tokens:\\n if token[-1] == \\\"?\\\":\\n if token.startswith(\\\"!\\\"):\\n skip = token[1:-1] in useflags\\n else:\\n skip = token[:-1] not in useflags\\n if skip:\\n level = 0\\n while 1:\\n token = next(tokens)\\n if token == \\\"(\\\":\\n level+=1\\n if token == \\\")\\\":\\n level-=1\\n if level < 1:\\n break\\n continue\\n elif token == \\\"(\\\" or token == \\\")\\\":\\n continue\\n else:\\n dest.append(token)\\n\\n return \\\" \\\".join(dest)\\n\\n # gjl does not use use flags\\n try:\\n use = os.environ[\\\"USE\\\"]\\n atoms = dep_string_reduce(atoms, use)\\n except KeyError:\\n pass\\n return atoms\",\n \"def test_dependency_interface():\\n c = TestClient()\\n conanfile = textwrap.dedent(\\\"\\\"\\\"\\n from conans import ConanFile\\n class Pkg(ConanFile):\\n name = \\\"dep\\\"\\n version = \\\"1.0\\\"\\n homepage = \\\"myhome\\\"\\n url = \\\"myurl\\\"\\n license = \\\"MIT\\\"\\n \\\"\\\"\\\")\\n user = textwrap.dedent(\\\"\\\"\\\"\\n from conan import ConanFile\\n class User(ConanFile):\\n requires = \\\"dep/1.0\\\"\\n def generate(self):\\n self.output.info(\\\"HOME: {}\\\".format(self.dependencies[\\\"dep\\\"].homepage))\\n self.output.info(\\\"URL: {}\\\".format(self.dependencies[\\\"dep\\\"].url))\\n self.output.info(\\\"LICENSE: {}\\\".format(self.dependencies[\\\"dep\\\"].license))\\n self.output.info(\\\"RECIPE: {}\\\".format(self.dependencies[\\\"dep\\\"].recipe_folder))\\n self.output.info(\\\"CONANDATA: {}\\\".format(self.dependencies[\\\"dep\\\"].conan_data))\\n\\n \\\"\\\"\\\")\\n c.save({\\\"dep/conanfile.py\\\": conanfile,\\n \\\"dep/conandata.yml\\\": \\\"\\\",\\n \\\"user/conanfile.py\\\": user})\\n c.run(\\\"create dep\\\")\\n c.run(\\\"install user\\\")\\n assert \\\"conanfile.py: HOME: myhome\\\" in c.out\\n assert \\\"conanfile.py: URL: myurl\\\" in c.out\\n assert \\\"conanfile.py: LICENSE: MIT\\\" in c.out\\n assert \\\"conanfile.py: RECIPE:\\\" in c.out\\n assert \\\"conanfile.py: CONANDATA: {}\\\" in c.out\",\n \"def test_extra_directives(modpath):\\n retcode, out = flake8(\\n join(modpath, \\\"RST303/sphinx-directives\\\"),\\n directives=\\\"req,spec,needfilter\\\",\\n )\\n assert not retcode, out\",\n \"def set_dependency_files(context):\\n path_to_direct_file = os.path.abspath('data/gemini_scan_data/direct-dependencies.txt')\\n path_to_transitive_file = os.path.abspath('data/gemini_scan_data/transitive-dependencies.txt')\\n context.dependency_files = list()\\n with open(path_to_direct_file, 'rb') as f:\\n context.dependency_files.append((\\n \\\"dependencyFile[]\\\",\\n (\\n 'direct-dependencies.txt',\\n f.read(),\\n 'text/plain'\\n )\\n ))\\n with open(path_to_transitive_file, 'rb') as f:\\n context.dependency_files.append((\\n \\\"dependencyFile[]\\\",\\n (\\n 'transitive-dependencies.txt',\\n f.read(),\\n 'text/plain'\\n )\\n ))\",\n \"def scanpatch(fp):\\n lr = patch.linereader(fp)\\n\\n def scanwhile(first, p):\\n \\\"\\\"\\\"scan lr while predicate holds\\\"\\\"\\\"\\n lines = [first]\\n while True:\\n line = lr.readline()\\n if not line:\\n break\\n if p(line):\\n lines.append(line)\\n else:\\n lr.push(line)\\n break\\n return lines\\n\\n while True:\\n line = lr.readline()\\n if not line:\\n break\\n if line.startswith('diff --git a/'):\\n def notheader(line):\\n s = line.split(None, 1)\\n return not s or s[0] not in ('---', 'diff')\\n header = scanwhile(line, notheader)\\n fromfile = lr.readline()\\n if fromfile.startswith('---'):\\n tofile = lr.readline()\\n header += [fromfile, tofile]\\n else:\\n lr.push(fromfile)\\n yield 'file', header\\n elif line[0] == ' ':\\n yield 'context', scanwhile(line, lambda l: l[0] in ' \\\\\\\\')\\n elif line[0] in '-+':\\n yield 'hunk', scanwhile(line, lambda l: l[0] in '-+\\\\\\\\')\\n else:\\n m = lines_re.match(line)\\n if m:\\n yield 'range', m.groups()\\n else:\\n raise patch.PatchError('unknown patch content: %r' % line)\",\n \"def read_line(self, line):\\n\\t\\tparts = line[:line.find(';')].split()\\n\\t\\tfor directive in self.directives:\\n\\t\\t\\tif directive in map(str.upper, parts):\\n\\t\\t\\t\\tinclude = os.path.join(self.path, parts[parts.index(directive) + 1].split('\\\"')[1])\\n\\t\\t\\t\\tif include not in self.includes:\\n\\t\\t\\t\\t\\tself.includes.append(include)\\n\\t\\t\\t\\t\\tself.read(include)\",\n \"def read_file(tp, ignoreincludes):\\n ret = []\\n filename, f = tp\\n\\n accumulate = \\\"\\\"\\n for lineno, line in enumerate(f):\\n lineno = lineno + 1 # number from 1\\n line = line.strip()\\n if not line: # preserve blanks\\n ret.append((line, filename, lineno))\\n continue\\n if line.endswith(\\\"\\\\\\\\\\\"):\\n accumulate += line[0:-1]\\n continue\\n elif accumulate:\\n line = accumulate + line\\n accumulate = \\\"\\\"\\n\\n if line:\\n line = apply_macros(line)\\n\\n line = line.strip()\\n\\n if not line:\\n continue\\n\\n try:\\n if line.startswith(\\\"<\\\") and line.endswith(\\\">\\\"):\\n if line.startswith(\\\"<include\\\"):\\n if not ignoreincludes:\\n line = line[1:-1]\\n line = line[7:].strip()\\n line = line.strip('\\\"')\\n ret.extend(read_file(\\n searching_open(line),\\n ignoreincludes))\\n else:\\n ret.append((line, filename, lineno))\\n elif line.startswith(\\\"<transform\\\"):\\n line = line[1:-1]\\n add_transform(line, filename, lineno)\\n else:\\n raise RuntimeError(_(\\\"unknown command {0}\\\").format(\\n line))\\n else:\\n ret.append((line, filename, lineno))\\n except RuntimeError as e:\\n error(_(\\\"File {file}, line {line:d}: {exception}\\\").format(\\n file=filename,\\n line=lineno,\\n exception=e),\\n exitcode=None)\\n raise RuntimeError(\\\"<included from>\\\")\\n\\n return ret\",\n \"def parse_deps_from_path(self, infile_path, classpath_indexer):\\r\\n with open(infile_path, 'r') as infile:\\r\\n return self.parse_deps(infile, classpath_indexer)\",\n \"def dependencies(spec, request=\\\"all\\\"):\\n if request not in (\\\"none\\\", \\\"direct\\\", \\\"all\\\"):\\n message = \\\"Wrong value for argument 'request' : \\\"\\n message += \\\"should be one of ('none', 'direct', 'all')\\\"\\n raise tty.error(message + \\\" [current value is '%s']\\\" % request)\\n\\n if request == \\\"none\\\":\\n return []\\n\\n if request == \\\"direct\\\":\\n return spec.dependencies(deptype=(\\\"link\\\", \\\"run\\\"))\\n\\n # FIXME : during module file creation nodes seem to be visited multiple\\n # FIXME : times even if cover='nodes' is given. This work around permits\\n # FIXME : to get a unique list of spec anyhow. Do we miss a merge\\n # FIXME : step among nodes that refer to the same package?\\n seen = set()\\n seen_add = seen.add\\n deps = sorted(\\n spec.traverse(order=\\\"post\\\", cover=\\\"nodes\\\", deptype=(\\\"link\\\", \\\"run\\\"), root=False),\\n reverse=True,\\n )\\n return [d for d in deps if not (d in seen or seen_add(d))]\",\n \"def compile_modules(base, output, source, bind=True):\\n return compile_files(base, output, source, bind, amd=True)\",\n \"def moduleCompletion(line):\\n def tryImport(mod, only_modules=False):\\n def isImportable(module, attr):\\n if only_modules:\\n return inspect.ismodule(getattr(module, attr))\\n else:\\n return not(attr[:2] == '__' and attr[-2:] == '__')\\n try:\\n m = __import__(mod)\\n except:\\n return []\\n mods = mod.split('.')\\n for module in mods[1:]:\\n m = getattr(m,module)\\n if (not hasattr(m, '__file__')) or (not only_modules) or\\\\\\n (hasattr(m, '__file__') and '__init__' in m.__file__):\\n completion_list = [attr for attr in dir(m) if isImportable(m, attr)]\\n completion_list.extend(getattr(m,'__all__',[]))\\n if hasattr(m, '__file__') and '__init__' in m.__file__:\\n completion_list.extend(moduleList(os.path.dirname(m.__file__)))\\n completion_list = list(set(completion_list))\\n if '__init__' in completion_list:\\n completion_list.remove('__init__')\\n return completion_list\\n\\n words = line.split(' ')\\n if len(words) == 3 and words[0] == 'from':\\n return ['import ']\\n if len(words) < 3 and (words[0] in ['import','from']) :\\n if len(words) == 1:\\n return getRootModules()\\n mod = words[1].split('.')\\n if len(mod) < 2:\\n return getRootModules()\\n completion_list = tryImport('.'.join(mod[:-1]), True)\\n completion_list = ['.'.join(mod[:-1] + [el]) for el in completion_list]\\n return completion_list\\n if len(words) >= 3 and words[0] == 'from':\\n mod = words[1]\\n return tryImport(mod)\",\n \"def _get_transitive_dependencies_helper(self, target, excluded_set, accumulator, depth_limit=30):\\n if depth_limit <= 0:\\n raise Exception(\\\"Dependency depth limit exceeded, resolving: %s\\\" % (str(target),) )\\n if target in excluded_set:\\n return\\n for c in self.get(target).requires:\\n if c not in excluded_set:\\n self._get_transitive_dependencies_helper(c, excluded_set, accumulator, depth_limit=depth_limit-1)\\n accumulator.append(target)\\n excluded_set.add(target)\",\n \"def scan_contents(self, sourcetree, keep_contents, detect_defines):\\n # TODO: Consider a more robust regex.\\n include_re = r'^\\\\s*#\\\\s*include\\\\s+(?P<quote>[\\\"<])(?P<path>[^\\\">]*)[\\\">]'\\n define_re = r'^\\\\s*#.*define(?:01)?\\\\s+(\\\\w*)'\\n current_block = None\\n with open(self._abspath, 'r') as scanfile:\\n contents = scanfile.read()\\n lines = contents.splitlines(True)\\n for lineno, line in enumerate(lines, 1):\\n match = re.match(include_re, line)\\n if match:\\n is_system = (match.group('quote') == '<')\\n includedpath = match.group('path')\\n included_file = self._process_include(lineno, is_system,\\n includedpath, line, sourcetree)\\n if current_block is None:\\n current_block = IncludeBlock(included_file)\\n self._include_blocks.append(current_block)\\n else:\\n current_block.add_file(included_file)\\n elif line and not line.isspace():\\n current_block = None\\n if detect_defines:\\n self._declared_defines = []\\n for line in lines:\\n match = re.match(define_re, line)\\n if match:\\n self._declared_defines.append(match.group(1))\\n if keep_contents:\\n self._lines = lines\",\n \"def main():\\n argp = argparse.ArgumentParser(prog='-mshlibs', description=('Print the '\\n 'complete list of shared libraries used by the specified binary '\\n 'file(s), (optionally including all child dependencies)'))\\n argp.add_argument('file', nargs='+', help='file(s) to report on')\\n argp.add_argument('-a', '--all', action=\\\"store_true\\\", help=(\\n \\\"recursively resolve all sub-dependencies\\\"))\\n args = argp.parse_args()\\n\\n if args.all:\\n deps = reduce(lambda a, b: a|b,\\n [all_libraries_used(f) for f in args.file])\\n else:\\n deps = reduce(lambda a, b: set(a)|set(b),\\n [libraries_used(f) for f in args.file])\\n\\n for path in sorted(deps):\\n print path\",\n \"def scan(self):\\n exclude_patterns_config = self.doxygen_config.get(\\\"EXCLUDE_PATTERNS\\\", [])\\n exclude_patterns = [\\n pattern.replace(\\\"*/\\\", \\\"**/\\\") for pattern in exclude_patterns_config\\n ]\\n file_patterns = self.doxygen_config.get(\\\"FILE_PATTERNS\\\", [\\\"*.c\\\", \\\"*.h\\\"])\\n if self.doxygen_config.get(\\\"RECURSIVE\\\", [\\\"YES\\\"]) == [\\\"YES\\\"]:\\n file_patterns = [f\\\"**/{pattern}\\\" for pattern in file_patterns]\\n nodes = []\\n names = []\\n for node in self.doxygen_input:\\n if os.path.isdir(node.abspath()):\\n for i in node.ant_glob(incl=file_patterns, excl=exclude_patterns):\\n nodes.append(i)\\n else:\\n nodes.append(node)\\n return (nodes, names)\",\n \"def grep(directory, include, findwhat, recursive=True, ignorecase=False, regexp=False, display=None, reversed=False):\\n\\tfrom os import walk\\n\\tfrom os.path import join\\n\\tfrom fnmatch import fnmatchcase\\n\\tfrom io import open\\n\\t\\n\\tdef __search(findwhat, content, ignorecase, regexp):\\n\\t\\t\\\"\\\"\\\" Search in content string \\\"\\\"\\\"\\n\\t\\tfrom re import search, IGNORECASE\\n\\t\\tif regexp:\\n\\t\\t\\tif ignorecase:\\n\\t\\t\\t\\tflag = IGNORECASE\\n\\t\\t\\telse:\\n\\t\\t\\t\\tflag = 0\\n\\t\\t\\tif search(findwhat, content, flag):\\n\\t\\t\\t\\treturn True\\n\\t\\telse:\\n\\t\\t\\tif ignorecase:\\n\\t\\t\\t\\tcontent = content.lower()\\n\\t\\t\\t\\tfindwhat = findwhat.lower()\\n\\t\\t\\t\\t\\n\\t\\t\\tif content.find(findwhat) != -1:\\n\\t\\t\\t\\treturn True\\n\\t\\treturn False\\n\\n\\tdef __grep(findwhat, filename, ignorecase, regexp):\\n\\t\\t\\\"\\\"\\\" Grep string in filename \\\"\\\"\\\"\\n\\t\\tresult = []\\n\\t\\ttry:\\n\\t\\t\\tencoding = \\\"utf8\\\"\\n\\t\\t\\tcontent = open(filename,\\\"r\\\", encoding=encoding).read()\\n\\t\\texcept FileNotFoundError:\\n\\t\\t\\treturn result\\n\\t\\texcept UnicodeDecodeError:\\n\\t\\t\\tencoding = \\\"latin-1\\\"\\n\\t\\t\\tcontent = open(filename,\\\"r\\\", encoding=encoding).read()\\n\\t\\t\\t\\n\\t\\tif __search(findwhat, content, ignorecase, regexp):\\n\\t\\t\\tlines = open(filename,\\\"r\\\", encoding=encoding).readlines()\\n\\t\\t\\tlineNumber = 1\\n\\t\\t\\tfor line in lines:\\n\\t\\t\\t\\tif __search(findwhat, line, ignorecase, regexp):\\n\\t\\t\\t\\t\\tresult.append((filename, lineNumber, line.strip()))\\n\\t\\t\\t\\tlineNumber += 1\\n\\t\\treturn result\\n\\n\\tresult = []\\n\\tfilesPatterns = include.split(\\\";\\\")\\n\\tfor dirpath, dummy, filenames in walk(directory):\\n\\t\\tfor filename in filenames:\\n\\t\\t\\tfor filePattern in filesPatterns:\\n\\t\\t\\t\\tif recursive or (recursive == False and dirpath == directory):\\n\\t\\t\\t\\t\\tif fnmatchcase(filename, filePattern):\\n\\t\\t\\t\\t\\t\\tfilename = join(dirpath,filename)\\n\\t\\t\\t\\t\\t\\tfounds = __grep(findwhat, filename, ignorecase, regexp)\\n\\t\\t\\t\\t\\t\\tresult += founds\\n\\t\\t\\t\\t\\t\\tif display != None:\\n\\t\\t\\t\\t\\t\\t\\tif reversed == False:\\n\\t\\t\\t\\t\\t\\t\\t\\tfor filename, line, content in founds:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif type(display) == type(True):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif display:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"%s:%d:%s\\\"%(filename, line, content))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdisplay(filename, line, content)\\n\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\tif founds == []:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\tif type(display) == type(True):\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tif display:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tprint(\\\"%s:0:not found\\\"%(filename, line, content))\\n\\t\\t\\t\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tdisplay(filename, 0, \\\"not found\\\")\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\n\\treturn result\",\n \"def get_dependency(self):\\n targets = [self.language.get_c_code_filename(),\\n self.language.get_c_header_filename(),\\n self.language.get_python_code_filename(),\\n self.language.get_python_autogenerated_module()]\\n dependencies = self.language.get_source_files()\\n return Dependency(dependencies, targets)\",\n \"def require():\",\n \"def all_dependencies(target, dep_context):\\n for dep in target.closure(bfs=True, **dep_context.target_closure_kwargs):\\n yield dep\",\n \"def process_modules(self) -> typing.NoReturn:\\n\\t\\tfor moduleName in self.moduleNameSet:\\n\\t\\t\\tdetected_encoding = detect_encoding(moduleName)\\n\\n\\t\\t\\tprint(f\\\"Processing {moduleName} ({detected_encoding})\\\")\\n\\n\\t\\t\\twith open(moduleName, 'r+', encoding=detected_encoding) as fileStream:\\n\\t\\t\\t\\t# Store the content of the file\\n\\t\\t\\t\\tfileContent: str = fileStream.read()\\n\\t\\t\\t\\t# Sets the file's current position at the offset, the position of the read/write pointer within the file\\n\\t\\t\\t\\tfileStream.seek(0, 0)\\n\\t\\t\\t\\t# Truncates the file's size\\n\\t\\t\\t\\tfileStream.truncate()\\n\\n\\t\\t\\t\\t# Process regex patterns\\n\\t\\t\\t\\tfor regexDict in regexDictList:\\n\\t\\t\\t\\t\\tfileContent = self.process_function(regexDict, fileContent)\\n\\n\\t\\t\\t\\t# Rewrite the processed content of the file\\n\\t\\t\\t\\tfileStream.write(fileContent)\",\n \"def main(argv=sys.argv):\\n parser = optparse.OptionParser(\\n usage=\\\"\\\"\\\"\\\\\\nusage: %prog [options] -o <output_path> <module_path> [exclude_paths, ...]\\n\\nLook recursively in <module_path> for Python modules and packages and create\\na reST file with automodule directives per package in the <output_path>.\\n\\nNote: By default this script will not overwrite already created files.\\\"\\\"\\\")\\n\\n parser.add_option('-o', '--output-dir', action='store', dest='destdir',\\n help='Directory to place all output', default='')\\n parser.add_option('-d', '--maxdepth', action='store', dest='maxdepth',\\n help='Maximum depth of submodules to show in the TOC '\\n '(default: 4)', type='int', default=4)\\n parser.add_option('-f', '--force', action='store_true', dest='force',\\n help='Overwrite all the files')\\n parser.add_option('-n', '--dry-run', action='store_true', dest='dryrun',\\n help='Run the script without creating the files')\\n parser.add_option('-T', '--no-toc', action='store_true', dest='notoc',\\n help='Don\\\\'t create the table of contents file')\\n parser.add_option('-H', '--doc-header', action='store', dest='header',\\n help='Documentation Header (default: Project)',\\n default='Project')\\n parser.add_option('-s', '--suffix', action='store', dest='suffix',\\n help='file suffix (default: rst)', default='rst')\\n\\n (opts, args) = parser.parse_args(argv[1:])\\n\\n if not args:\\n parser.error('A package path is required.')\\n if not opts.destdir:\\n parser.error('An output directory is required.')\\n rootpath, excludes = args[0], args[1:]\\n\\n use_module = False\\n try:\\n __import__(rootpath)\\n use_module = True\\n except ImportError:\\n if not path.isdir(rootpath):\\n print >>sys.stderr, '%s is not a directory.' % rootpath\\n sys.exit(1)\\n use_module = False\\n\\n if not path.isdir(opts.destdir):\\n print '%s is not a valid output directory.' % opts.destdir\\n sys.exit(1)\\n\\n if not use_module:\\n excludes = normalize_excludes(rootpath, excludes)\\n recurse_tree(rootpath, excludes, opts, use_module)\",\n \"def _get_dependencies(requirements_file: Path) -> List[str]:\\n lines = requirements_file.read_text().strip().split('\\\\n')\\n return [line for line in lines if not line.startswith('#')]\",\n \"def GetModules(cls, file):\\n modules = set([])\\n with open(file, 'r') as f:\\n lines = f.readlines()\\n for line in lines:\\n for sig in ModuleFinder.__signatures:\\n match = sig.match(line)\\n if match:\\n module = match[1].split('.')[0]\\n # Remove alias:\\n module = ModuleFinder.__removeAlias.sub('', module)\\n modules.add(module)\\n break\\n return modules\",\n \"def defined_submodule(arr):\\n return any([el.endswith('_module]') for el in arr])\",\n \"def test_dependencies_visit_build_requires_profile():\\n # https://github.com/conan-io/conan/issues/10304\\n client = TestClient()\\n client.save({\\\"conanfile.py\\\": GenConanfile()})\\n client.run(\\\"create . cmake/0.1@\\\")\\n conanfile = textwrap.dedent(\\\"\\\"\\\"\\n from conans import ConanFile\\n class Pkg(ConanFile):\\n\\n def validate(self):\\n self.output.info(\\\"VALIDATE DEPS: {}!!!\\\".format(len(self.dependencies.items())))\\n\\n def generate(self):\\n for req, dep in self.dependencies.items():\\n self.output.info(\\\"GENERATE REQUIRE: {}!!!\\\".format(dep.ref))\\n dep = self.dependencies.build[\\\"cmake\\\"]\\n self.output.info(\\\"GENERATE CMAKE: {}!!!\\\".format(dep.ref))\\n \\\"\\\"\\\")\\n client.save({\\\"conanfile.py\\\": conanfile,\\n \\\"profile\\\": \\\"[build_requires]\\\\ncmake/0.1\\\"})\\n client.run(\\\"install . -pr:b=default -pr:h=profile --build\\\") # Use 2 contexts\\n # Validate time, build-requires not available yet\\n assert \\\"conanfile.py: VALIDATE DEPS: 0!!!\\\" in client.out\\n # generate time, build-requires already available\\n assert \\\"conanfile.py: GENERATE REQUIRE: cmake/0.1!!!\\\" in client.out\\n assert \\\"conanfile.py: GENERATE CMAKE: cmake/0.1!!!\\\" in client.out\",\n \"def checkRequiredDependencies(self):\\n \\n # skip dependency check for downloading only\\n if( self.downloadOnly ):\\n return\\n\\n # hard dependencies\\n for req in self.reqmodules:\\n if( self.parent.module(req) == None ):\\n # check if there is an auto detected module\\n if( self.parent.module(req, True) == None ):\\n self.abort( self.name + \\\" requires \\\" + req \\\\\\n + \\\" and it wasn't found in your config file!!\\\" )\\n else:\\n # use auto detected module\\n self.parent.use( self.parent.module(req, True) )\\n self.parent.module( req ).init()\\n\\n print self.name + \\\": auto-detected \\\" + req + \\\" version \\\" + self.parent.module( req ).version\\n \\n # build only dependencies\\n if( self.mode == \\\"install\\\" ):\\n mods = self.reqmodules_buildonly + self.reqmodules_external\\n for req in mods:\\n if( self.parent.module(req) == None ):\\n # check if there is an auto detected module\\n if( self.parent.module(req, True) == None ):\\n self.abort( req + \\\" not found in your config file!! \\\" + self.name \\\\\\n + \\\" cannot be built without \\\" + req )\\n else:\\n # use auto detected module\\n self.parent.use( self.parent.module(req, True) )\\n self.parent.module( req ).init()\\n\\n print \\\" - \\\" + self.name + \\\": auto-detected \\\" + req + \\\" version \\\" + self.parent.module( req ).version\",\n \"def clsources(ctx):\\n\\t# TODO Use regex instead\\n\\t# this is a poor-man's hack, it relies on the assumption that files\\n\\t# start and end with parenthesis. Put a comment before, and you generate\\n\\t# wrong code. But the source is under my control anyways.\\n\\tfloat_srcfolder = ctx.path.find_node(inc + \\\"/ukoct/opencl/float/sources\\\")\\n\\tcommon_clsources = ctx.path.ant_glob(inc + \\\"/ukoct/opencl/common/**/*.cl\\\")\\n\\tfloat_clsources = [\\n\\t\\tfloat_srcfolder.find_node(\\\"defs.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"coherent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"consistent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"intConsistent.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"closed.inc.cl\\\"),\\n\\t\\tfloat_srcfolder.find_node(\\\"stronglyClosed.inc.cl\\\"),\\n\\t]\\n\\tfloat_clsource = []\\n\\tfor node in common_clsources:\\n\\t\\tsource = node.read()\\n\\t\\tfloat_clsource.append(source[source.find(\\\"(\\\") + 1 : source.rfind(\\\")\\\")])\\n\\tfor node in float_clsources:\\n\\t\\tsource = node.read()\\n\\t\\tfloat_clsource.append(source[source.find(\\\"(\\\") + 1 : source.rfind(\\\")\\\")])\\n\\tctx.path.make_node(\\\"float.cl\\\").write(''.join(float_clsource))\",\n \"def get_makefile_dependencies(self, template: Union[Path, str]) -> List[Path]:\\n if isinstance(template, Path):\\n template = template.read_text()\\n dependencies = self.variable_files + self.yasha_extensions_files\\n referenced_template_partials = find_referenced_templates(self.env.parse(template)) # returns a generator\\n # convert the generator to a list, filtering out the None values\\n referenced_template_partials: List[str] = list(filter(bool, referenced_template_partials))\\n\\n for relative_path in referenced_template_partials:\\n for basepath in self.env.loader.searchpath: # type: ignore\\n if not isinstance(basepath, Path): basepath = Path(basepath)\\n template_path = basepath / relative_path\\n if template_path.is_file:\\n # we've found the template partial inside this basepath\\n dependencies.append(template_path)\\n return dependencies\",\n \"def check_custom_deps(path, deps):\\n for key, value in deps.items():\\n for regex in value['regex']:\\n if re.match(r'' + regex, path):\\n return key\\n return None\",\n \"def test_include(f2003_create):\\n # Use the Main Program rule R1101 as an example\\n startcls = F2003.Program_Stmt\\n subclasses = [\\n F2003.Specification_Part,\\n F2003.Execution_Part,\\n F2003.Internal_Subprogram_Part,\\n ]\\n endcls = F2003.End_Program_Stmt\\n reader = get_reader(\\n (\\n \\\"include '1'\\\\n\\\"\\n \\\"! comment1\\\\n\\\"\\n \\\"program test\\\\n\\\"\\n \\\"include '2'\\\\n\\\"\\n \\\"! comment2\\\\n\\\"\\n \\\"integer :: i\\\\n\\\"\\n \\\"include '3'\\\\n\\\"\\n \\\"! comment3\\\\n\\\"\\n \\\"i=1\\\\n\\\"\\n \\\"include '4'\\\\n\\\"\\n \\\"! comment4\\\\n\\\"\\n \\\"contains\\\\n\\\"\\n \\\"include '5'\\\\n\\\"\\n \\\"! comment5\\\\n\\\"\\n \\\"end program test\\\\n\\\"\\n \\\"! I should be ignored\\\"\\n \\\"include 'so should I'\\\"\\n ),\\n ignore_comments=False,\\n )\\n result = BlockBase.match(startcls, subclasses, endcls, reader)\\n assert (\\n \\\"([Include_Stmt(Include_Filename('1')), Comment('! comment1'), \\\"\\n \\\"Program_Stmt('PROGRAM', Name('test')), Specification_Part(\\\"\\n \\\"Implicit_Part(Include_Stmt(Include_Filename('2')), \\\"\\n \\\"Comment('! comment2')), Type_Declaration_Stmt(Intrinsic_Type_Spec(\\\"\\n \\\"'INTEGER', None), None, Entity_Decl_List(',', (Entity_Decl(Name(\\\"\\n \\\"'i'), None, None, None),))), Implicit_Part(Include_Stmt(\\\"\\n \\\"Include_Filename('3')), Comment('! comment3'))), Execution_Part(\\\"\\n \\\"Assignment_Stmt(Name('i'), '=', Int_Literal_Constant('1', None)), \\\"\\n \\\"Include_Stmt(Include_Filename('4')), Comment('! comment4')), \\\"\\n \\\"Internal_Subprogram_Part(Contains_Stmt('CONTAINS'), Include_Stmt(\\\"\\n \\\"Include_Filename('5')), Comment('! comment5')), End_Program_Stmt(\\\"\\n \\\"'PROGRAM', Name('test'))],)\\\" in str(result).replace(\\\"u'\\\", \\\"'\\\")\\n )\\n assert \\\"should\\\" not in str(result)\",\n \"def _parse_gradle_files(moduleDir: str, gradleFilepaths: Set[str])\\\\\\n -> List[ModuleInfo]:\\n\\n moduleInfo = []\\n\\n for filepath in gradleFilepaths:\\n with open(filepath, 'r') as f:\\n for l in f:\\n line = l.strip()\\n if line and GRADLE_PROJECT_NAME_REGEX.match(l):\\n moduleInfo.append(ModuleInfo(moduleDir, filepath, set()))\\n break\\n\\n return moduleInfo\",\n \"def _set_dependencies(self, analysis, path):\\n for toc in (analysis.binaries, analysis.datas):\\n for i, tpl in enumerate(toc):\\n if not tpl[1] in self._dependencies:\\n logger.debug(\\\"Adding dependency %s located in %s\\\", tpl[1], path)\\n self._dependencies[tpl[1]] = path\\n else:\\n dep_path = self._get_relative_path(path, self._dependencies[tpl[1]])\\n # Ignore references that point to the origin package. This can happen if the same resource is listed\\n # multiple times in TOCs (e.g., once as binary and once as data).\\n if dep_path.endswith(path):\\n logger.debug(\\n \\\"Ignoring self-reference of %s for %s, located in %s - duplicated TOC entry?\\\", tpl[1], path,\\n dep_path\\n )\\n # Clear the entry as it is a duplicate.\\n toc[i] = (None, None, None)\\n continue\\n logger.debug(\\\"Referencing %s to be a dependency for %s, located in %s\\\", tpl[1], path, dep_path)\\n # Determine the path relative to dep_path (i.e, within the target directory) from the 'name'\\n # component of the TOC tuple. If entry is EXTENSION, then the relative path needs to be\\n # reconstructed from the name components.\\n if tpl[2] == 'EXTENSION':\\n # Split on os.path.sep first, to handle additional path prefix (e.g., lib-dynload)\\n ext_components = tpl[0].split(os.path.sep)\\n ext_components = ext_components[:-1] + ext_components[-1].split('.')[:-1]\\n if ext_components:\\n rel_path = os.path.join(*ext_components)\\n else:\\n rel_path = ''\\n else:\\n rel_path = os.path.dirname(tpl[0])\\n # Take filename from 'path' (second component of TOC tuple); this way, we don't need to worry about\\n # suffix of extensions.\\n filename = os.path.basename(tpl[1])\\n # Construct the full file path relative to dep_path...\\n filename = os.path.join(rel_path, filename)\\n # ...and use it in new DEPENDENCY entry\\n analysis.dependencies.append((\\\":\\\".join((dep_path, filename)), tpl[1], \\\"DEPENDENCY\\\"))\\n toc[i] = (None, None, None)\\n # Clean the list\\n toc[:] = [tpl for tpl in toc if tpl != (None, None, None)]\",\n \"def expand_files(self, recursive=True, include_buildfile=True):\\r\\n\\r\\n files = []\\r\\n\\r\\n def _expand(target):\\r\\n files.extend([os.path.abspath(os.path.join(target.target_base, s))\\r\\n for s in (target.sources or [])])\\r\\n if include_buildfile:\\r\\n files.append(target.address.buildfile.full_path)\\r\\n if recursive:\\r\\n for dep in target.dependencies:\\r\\n if isinstance(dep, TargetWithSources):\\r\\n _expand(dep)\\r\\n elif hasattr(dep, 'address'):\\r\\n # Don't know what it is, but we'll include the BUILD file to be paranoid\\r\\n files.append(dep.address.buildfile.full_path)\\r\\n\\r\\n _expand(self)\\r\\n return files\",\n \"def add_dependency(kernel, insn_match, depends_on):\\n\\n if isinstance(depends_on, str) and depends_on in kernel.id_to_insn:\\n added_deps = frozenset([depends_on])\\n else:\\n added_deps = frozenset(\\n dep.id for dep in find_instructions_in_single_kernel(kernel,\\n depends_on))\\n\\n if not added_deps:\\n raise LoopyError(\\\"no instructions found matching '%s' \\\"\\n \\\"(to add as dependencies)\\\" % depends_on)\\n\\n matched = [False]\\n\\n def add_dep(insn):\\n new_deps = insn.depends_on\\n matched[0] = True\\n if new_deps is None:\\n new_deps = added_deps\\n else:\\n new_deps = new_deps | added_deps\\n\\n return insn.copy(depends_on=new_deps)\\n\\n result = map_instructions(kernel, insn_match, add_dep)\\n\\n if not matched[0]:\\n raise LoopyError(\\\"no instructions found matching '%s' \\\"\\n \\\"(to which dependencies would be added)\\\" % insn_match)\\n\\n return result\",\n \"def parse_dependency_links(*filenames):\\n dependency_links = []\\n for f in filenames:\\n for line in open(f, 'r').read().split('\\\\n'):\\n if re.match(r'\\\\s*-[ef]\\\\s+', line):\\n line = re.sub(r'\\\\s*-[ef]\\\\s+', '', line)\\n line = re.sub(r'\\\\s*git\\\\+https', 'http', line)\\n line = re.sub(r'\\\\.git#', '/tarball/master#', line)\\n dependency_links.append(line)\\n return dependency_links\",\n \"def analyse_files_against_regex_pattern(files, pattern):\\n # boolean to check if docs are to be generated\\n comments_for_jsdoc_exists = False\\n # reading file content and comparing with pattern\\n for filepath in files:\\n if comments_for_jsdoc_exists:\\n break\\n with open(filepath, encoding='utf-8') as code:\\n file_content = code.read()\\n matches = pattern.search(file_content)\\n if matches:\\n comments_for_jsdoc_exists = True\\n break\\n\\n return comments_for_jsdoc_exists\",\n \"def checkDependencies(check=True):\\n modules = []\\n f = open(CONST_REQUIREMENTS_FILE)\\n for line in f:\\n if line.find('#'):\\n modules.append([line[:line.index('=')], (line[line.index('=')+2:]).strip()])\\n f.close()\\n\\n for module in modules:\\n try:\\n __import__(module[0])\\n except ImportError: \\n if query_user_bool(\\\"Missing module %s.\\\" \\\\\\n \\\" Do you wish to install it?\\\" % module[0]):\\n subprocess.call([\\\"pip2\\\", \\\"install\\\", \\\"%s==%s\\\" %\\n (module[0], module[1])])\\n \\n else:\\n return False\\n return True\",\n \"def test_case_6():\\n print(\\\"*********Test_case_6***********\\\")\\n path = os.path.join(os.path.dirname(__file__), 'testdir', 't1.c')\\n result = find_files('.c', path)\\n print(result)\",\n \"def test_case_3():\\n print(\\\"*********Test_case_3***********\\\")\\n result = find_files('.c', None)\\n print(result)\",\n \"def find_dependencies(self, dependent_rev, recurse=None):\\n if recurse is None:\\n recurse = self.options.recurse\\n\\n try:\\n dependent = self.get_commit(dependent_rev)\\n except InvalidCommitish as e:\\n abort(e.message())\\n\\n self.todo.append(dependent)\\n self.todo_d[dependent.hex] = True\\n\\n while self.todo:\\n sha1s = [commit.hex[:8] for commit in self.todo]\\n self.logger.debug(\\\"TODO list: %s\\\" % \\\" \\\".join(sha1s))\\n dependent = self.todo.pop(0)\\n del self.todo_d[dependent.hex]\\n self.logger.debug(\\\"Processing %s from TODO list\\\" %\\n dependent.hex[:8])\\n self.notify_listeners('new_commit', dependent)\\n\\n for parent in dependent.parents:\\n self.find_dependencies_with_parent(dependent, parent)\\n self.done.append(dependent.hex)\\n self.done_d[dependent.hex] = True\\n self.logger.debug(\\\"Found all dependencies for %s\\\" %\\n dependent.hex[:8])\\n # A commit won't have any dependencies if it only added new files\\n dependencies = self.dependencies.get(dependent.hex, {})\\n self.notify_listeners('dependent_done', dependent, dependencies)\\n\\n self.notify_listeners('all_done')\",\n \"def check_file_valid_input(config, modname, fname, fdict, indent=''):\\n\\n cnts = [0] * NUMCNTS\\n\\n # check that any given filename pattern has a definition\\n if pfwdefs.SW_FILEPAT in fdict:\\n cnts2 = check_filepat_valid(config, fdict[pfwdefs.SW_FILEPAT], modname, fname, indent+' ')\\n cnts = [x + y for x, y in zip(cnts, cnts2)] # increment counts\\n\\n # check that it has filepat, filename, depends, or query wcl (required)\\n # if filename is a pattern, can I check that all needed values exist?\\n # todo check depends happens in same block previous to this module\\n if (('listonly' not in fdict or not miscutils.convertBool(fdict['listonly'])) and\\n pfwdefs.SW_FILEPAT not in fdict and pfwdefs.FILENAME not in fdict and\\n 'fullname' not in fdict and 'query_fields' not in fdict and pfwdefs.DATA_DEPENDS not in fdict):\\n error(indent, \\\"module %s, %s, %s - Missing terms needed to determine input filename\\\" % (modname, pfwdefs.SW_INPUTS, fname))\\n cnts[ERRCNT_POS] += 1\\n\\n # check that it has pfwdefs.DIRPAT : err\\n # can I check that all values for pfwdefs.DIRPAT exist?\\n if pfwdefs.DIRPAT not in fdict:\\n error(indent, \\\"module %s, %s, %s - Missing %s\\\" % (modname, pfwdefs.SW_INPUTS, fname, pfwdefs.DIRPAT))\\n cnts[ERRCNT_POS] += 1\\n\\n return cnts\",\n \"def learn_requirements():\\n req_file = \\\"requirements.txt\\\"\\n reqs = []\\n\\n import os\\n\\n path = os.path.dirname(__file__)\\n req_file = os.path.join(path, \\\"..\\\", req_file)\\n if not os.path.exists(req_file):\\n # not needed with installed package\\n return reqs\\n\\n excludes = \\\"versioneer coveralls coverage\\\".split()\\n with open(req_file, \\\"r\\\") as fp:\\n buf = fp.read().strip().splitlines()\\n for req in buf:\\n req = req.strip()\\n if (\\n req != \\\"\\\"\\n and not req.startswith(\\\"#\\\")\\n and req not in excludes\\n ):\\n reqs.append(req)\\n return reqs\",\n \"def get_requires(path=REQUIRE_PATH):\\n for line in read(path).splitlines():\\n line = line.strip()\\n if line and not line.startswith('#'):\\n yield line\",\n \"def strict_dependencies(target, dep_context):\\n for declared in _resolve_aliases(target):\\n if isinstance(declared, dep_context.compiler_plugin_types):\\n for r in declared.closure(bfs=True, **dep_context.target_closure_kwargs):\\n yield r\\n else:\\n yield declared\",\n \"def find_modules(inFile):\\n pkgName= determinePackage(inFile)\\n fileDir= os.path.dirname(inFile)\\n files= os.listdir(fileDir)\\n \\n files= [ os.path.join( fileDir, aFile) for aFile in files if aFile.endswith(\\\".py\\\") ]\\n \\n moduleDict= {}\\n for aFile in files:\\n fileNoExtName= os.path.basename(aFile)[:-3]\\n \\n \\n if pkgName is None:\\n modObj= importlib.import_module( fileNoExtName, fileDir )\\n else:\\n pkgAndFile= \\\".\\\".join( [pkgName, fileNoExtName] )\\n modObj= importlib.import_module( pkgAndFile, os.path.dirname(fileDir) )\\n \\n moduleDict[aFile]= modObj\\n \\n return moduleDict\",\n \"def run(self):\\n\\n # from sphynx Include Directive in https://github.com/sphinx-doc/sphinx/blob/master/sphinx/directives/other.py\\n # type: () -> List[nodes.Node]\\n env = self.state.document.settings.env\\n if self.arguments[0].startswith('<') and \\\\\\n self.arguments[0].endswith('>'):\\n # docutils \\\"standard\\\" includes, do not do path processing\\n return BaseInclude.run(self)\\n rel_filename, filename = env.relfn2path(self.arguments[0])\\n self.arguments[0] = filename\\n env.note_included(filename)\\n #end\\n\\n if not self.state.document.settings.file_insertion_enabled:\\n raise self.warning('\\\"%s\\\" directive disabled.' % self.name)\\n source = self.state_machine.input_lines.source(\\n self.lineno - self.state_machine.input_offset - 1)\\n source_dir = os.path.dirname(os.path.abspath(source))\\n path = directives.path(self.arguments[0])\\n if path.startswith('<') and path.endswith('>'):\\n path = os.path.join(self.standard_include_path, path[1:-1])\\n path = os.path.normpath(os.path.join(source_dir, path))\\n path = utils.relative_path(None, path)\\n path = nodes.reprunicode(path)\\n encoding = self.options.get(\\n 'encoding', self.state.document.settings.input_encoding)\\n e_handler=self.state.document.settings.input_encoding_error_handler\\n tab_width = self.options.get(\\n 'tab-width', self.state.document.settings.tab_width)\\n try:\\n self.state.document.settings.record_dependencies.add(path)\\n include_file = io.FileInput(source_path=path,\\n encoding=encoding,\\n error_handler=e_handler)\\n except UnicodeEncodeError as error:\\n raise self.severe(u'Problems with \\\"%s\\\" directive path:\\\\n'\\n 'Cannot encode input file path \\\"%s\\\" '\\n '(wrong locale?).' %\\n (self.name, SafeString(path)))\\n except IOError as error:\\n raise self.severe(u'Problems with \\\"%s\\\" directive path:\\\\n%s.' %\\n (self.name, ErrorString(error)))\\n startline = self.options.get('start-line', None)\\n endline = self.options.get('end-line', None)\\n try:\\n if startline or (endline is not None):\\n lines = include_file.readlines()\\n rawtext = ''.join(lines[startline:endline])\\n else:\\n rawtext = include_file.read()\\n except UnicodeError as error:\\n raise self.severe(u'Problem with \\\"%s\\\" directive:\\\\n%s' %\\n (self.name, ErrorString(error)))\\n # start-after/end-before: no restrictions on newlines in match-text,\\n # and no restrictions on matching inside lines vs. line boundaries\\n after_text = self.options.get('start-after', None)\\n if after_text:\\n # skip content in rawtext before *and incl.* a matching text\\n after_index = rawtext.find(after_text)\\n if after_index < 0:\\n raise self.severe('Problem with \\\"start-after\\\" option of \\\"%s\\\" '\\n 'directive:\\\\nText not found.' % self.name)\\n rawtext = rawtext[after_index + len(after_text):]\\n before_text = self.options.get('end-before', None)\\n if before_text:\\n # skip content in rawtext after *and incl.* a matching text\\n before_index = rawtext.find(before_text)\\n if before_index < 0:\\n raise self.severe('Problem with \\\"end-before\\\" option of \\\"%s\\\" '\\n 'directive:\\\\nText not found.' % self.name)\\n rawtext = rawtext[:before_index]\\n\\n # Handle alternate comment styles\\n style = self.options.get('style', 'C-style')\\n if style not in COMMENT_STYLES:\\n raise self.severe('Cannot find comment style \\\"%s\\\", not in %s'\\n % (style, COMMENT_STYLES.keys()))\\n self.comment_options = COMMENT_STYLES[style]\\n\\n rawtext = self.filterText(rawtext)\\n #if (path == \\\"../examples/neuropil_hydra.c\\\"):\\n #raise self.severe('filterd text from %s:\\\\n%s' % (path, rawtext))\\n\\n include_lines = statemachine.string2lines(rawtext, tab_width,\\n convert_whitespace=True)\\n if 'literal' in self.options:\\n # Convert tabs to spaces, if `tab_width` is positive.\\n if tab_width >= 0:\\n text = rawtext.expandtabs(tab_width)\\n else:\\n text = rawtext\\n literal_block = nodes.literal_block(rawtext, source=path,\\n classes=self.options.get('class', []))\\n literal_block.line = 1\\n self.add_name(literal_block)\\n if 'number-lines' in self.options:\\n try:\\n startline = int(self.options['number-lines'] or 1)\\n except ValueError:\\n raise self.error(':number-lines: with non-integer '\\n 'start value')\\n endline = startline + len(include_lines)\\n if text.endswith('\\\\n'):\\n text = text[:-1]\\n tokens = NumberLines([([], text)], startline, endline)\\n for classes, value in tokens:\\n if classes:\\n literal_block += nodes.inline(value, value,\\n classes=classes)\\n else:\\n literal_block += nodes.Text(value, value)\\n else:\\n literal_block += nodes.Text(text, text)\\n return [literal_block]\\n if 'code' in self.options:\\n self.options['source'] = path\\n codeblock = CodeBlock(self.name,\\n [self.options.pop('code')], # arguments\\n self.options,\\n include_lines, # content\\n self.lineno,\\n self.content_offset,\\n self.block_text,\\n self.state,\\n self.state_machine)\\n return codeblock.run()\\n\\n self.state_machine.insert_input(include_lines, path)\\n return []\",\n \"def main():\\n args = docopt(__doc__)\\n meta = fetch_metadata(args['DIRECTORY'], **args)\\n if args['--fasta']:\\n meta.assembly.update({'file': args['--fasta']})\\n taxdump = None\\n dependencies = {}\\n for field in FIELDS:\\n if args[field['flag']]:\\n for dep in field['depends']:\\n if dep not in dependencies or not dependencies[dep]:\\n dependencies[dep] = fetch_field(args['DIRECTORY'], dep, meta)\\n if field['flag'] == '--hits':\\n if not taxdump:\\n taxdump = fetch_taxdump(args['--taxdump'])\\n parents = field['module'].parent()\\n parsed = field['module'].parse(\\n args[field['flag']],\\n **{key: args[key] for key in PARAMS},\\n taxdump=taxdump,\\n dependencies=dependencies,\\n meta=meta)\\n if not isinstance(parsed, list):\\n parsed = [parsed]\\n for data in parsed:\\n if not args['--replace']:\\n if has_field_warning(meta, data.field_id):\\n continue\\n for parent in data.parents:\\n if 'range' in parent:\\n parent_meta = meta.field_meta(parent['id'])\\n if parent_meta and 'range' in parent_meta:\\n parent['range'][0] = min(parent['range'][0], parent_meta['range'][0])\\n parent['range'][1] = max(parent['range'][1], parent_meta['range'][1])\\n meta.add_field(parents+data.parents, **data.meta)\\n if isinstance(data, Identifier):\\n meta.records = len(data.values)\\n json_file = \\\"%s/%s.json\\\" % (args['DIRECTORY'], data.field_id)\\n file_io.write_file(json_file, data.values_to_dict())\\n dependencies[data.field_id] = data\\n if 'identifiers' not in dependencies:\\n dependencies['identifiers'] = fetch_field(args['DIRECTORY'], 'identifiers', meta)\\n for string in args['--link']:\\n link.add(string, meta, dependencies['identifiers'].values, args['--skip-link-test'])\\n for string in args['--key']:\\n key.add(string, meta)\\n if args['--taxid']:\\n if not taxdump:\\n taxdump = fetch_taxdump(args['--taxdump'])\\n taxid.add(args['--taxid'], taxdump, meta)\\n file_io.write_file(\\\"%s/meta.json\\\" % args['DIRECTORY'], meta.to_dict())\",\n \"def test_module_doc():\\r\\n\\r\\n for fname in os.listdir('.'):\\r\\n if fname.endswith('.py'):\\r\\n f = fname.split('.')[0]\\r\\n print 'Executing ', fname\\r\\n execfile(fname, locals())\",\n \"def get_includes(self):\\r\\n def visitor(fobj, lptr, depth, includes):\\r\\n if depth > 0:\\r\\n loc = lptr.contents\\r\\n includes.append(FileInclusion(loc.file, File(fobj), loc, depth))\\r\\n\\r\\n # Automatically adapt CIndex/ctype pointers to python objects\\r\\n includes = []\\r\\n conf.lib.clang_getInclusions(self,\\r\\n callbacks['translation_unit_includes'](visitor), includes)\\r\\n\\r\\n return iter(includes)\",\n \"def crunch(self):\\n while True:\\n lst = self.want_line(r'\\\\s*\\\\.file\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.globl\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.ident\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.section\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.type\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.size\\\\s+(.*)')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.(bss)\\\\s+')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.(data)\\\\s+')\\n if lst:\\n self.erase(lst[0])\\n continue\\n lst = self.want_line(r'\\\\s*\\\\.(text)\\\\s+')\\n if lst:\\n self.erase(lst[0])\\n continue\\n break\\n if osarch_is_amd64():\\n self.crunch_amd64(lst)\\n elif osarch_is_ia32():\\n self.crunch_ia32(lst)\\n self.__tag = None\",\n \"def findModule(name):\",\n \"def parse_dependency(dep, forge):\\n if '|' in dep:\\n return [parse_dependency(alt, forge) for alt in dep.split('|')]\\n dep = dep.strip()\\n name = ''\\n version = ''\\n arch = ''\\n version, dep = extract_text(dep)\\n arch, dep = extract_text(dep, ('[', ']'))\\n name = dep.strip()\\n return {'forge': forge, 'product': name,\\n 'constraints': use_mvn_spec(version), 'architectures': arch}\",\n \"def get_dependencies_content():\\n import trustedanalytics\\n dependencies = []\\n for filename in trustedanalytics.udf_dependencies:\\n name, content = _get_file_content_as_str(filename)\\n dependencies.append({'file_name': name, 'file_content': content})\\n return dependencies\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.66169536","0.61312497","0.58868647","0.5637438","0.55885524","0.5586976","0.5523092","0.5467778","0.5432288","0.5417047","0.5335516","0.519833","0.51949865","0.51465106","0.5142541","0.5124167","0.5095581","0.50270045","0.5003758","0.49810615","0.49445158","0.49398267","0.48794067","0.4865043","0.48591664","0.48571917","0.48447096","0.483119","0.48221153","0.48210844","0.48202288","0.4817026","0.4810364","0.48047125","0.4803157","0.48000082","0.47953758","0.47860697","0.47593695","0.47532293","0.47513494","0.4746215","0.4741036","0.47395262","0.47390312","0.47353125","0.47289932","0.47233364","0.46944392","0.46818528","0.46785545","0.46750447","0.4673405","0.46708223","0.46617156","0.4641263","0.46389922","0.4638947","0.4638476","0.4634732","0.46336013","0.4630182","0.4623111","0.4621586","0.4617173","0.46149603","0.46089235","0.46087036","0.45996964","0.4585787","0.45804024","0.45786133","0.4573039","0.4572638","0.4572522","0.4571749","0.45629475","0.45523953","0.45515656","0.45498607","0.4534995","0.4532838","0.45280117","0.45237753","0.45176497","0.45171344","0.45130104","0.4512844","0.4511805","0.4507805","0.450739","0.4507077","0.45051634","0.44965267","0.44945085","0.4492598","0.44911635","0.44904253","0.44824722","0.44788268"],"string":"[\n \"0.66169536\",\n \"0.61312497\",\n \"0.58868647\",\n \"0.5637438\",\n \"0.55885524\",\n \"0.5586976\",\n \"0.5523092\",\n \"0.5467778\",\n \"0.5432288\",\n \"0.5417047\",\n \"0.5335516\",\n \"0.519833\",\n \"0.51949865\",\n \"0.51465106\",\n \"0.5142541\",\n \"0.5124167\",\n \"0.5095581\",\n \"0.50270045\",\n \"0.5003758\",\n \"0.49810615\",\n \"0.49445158\",\n \"0.49398267\",\n \"0.48794067\",\n \"0.4865043\",\n \"0.48591664\",\n \"0.48571917\",\n \"0.48447096\",\n \"0.483119\",\n \"0.48221153\",\n \"0.48210844\",\n \"0.48202288\",\n \"0.4817026\",\n \"0.4810364\",\n \"0.48047125\",\n \"0.4803157\",\n \"0.48000082\",\n \"0.47953758\",\n \"0.47860697\",\n \"0.47593695\",\n \"0.47532293\",\n \"0.47513494\",\n \"0.4746215\",\n \"0.4741036\",\n \"0.47395262\",\n \"0.47390312\",\n \"0.47353125\",\n \"0.47289932\",\n \"0.47233364\",\n \"0.46944392\",\n \"0.46818528\",\n \"0.46785545\",\n \"0.46750447\",\n \"0.4673405\",\n \"0.46708223\",\n \"0.46617156\",\n \"0.4641263\",\n \"0.46389922\",\n \"0.4638947\",\n \"0.4638476\",\n \"0.4634732\",\n \"0.46336013\",\n \"0.4630182\",\n \"0.4623111\",\n \"0.4621586\",\n \"0.4617173\",\n \"0.46149603\",\n \"0.46089235\",\n \"0.46087036\",\n \"0.45996964\",\n \"0.4585787\",\n \"0.45804024\",\n \"0.45786133\",\n \"0.4573039\",\n \"0.4572638\",\n \"0.4572522\",\n \"0.4571749\",\n \"0.45629475\",\n \"0.45523953\",\n \"0.45515656\",\n \"0.45498607\",\n \"0.4534995\",\n \"0.4532838\",\n \"0.45280117\",\n \"0.45237753\",\n \"0.45176497\",\n \"0.45171344\",\n \"0.45130104\",\n \"0.4512844\",\n \"0.4511805\",\n \"0.4507805\",\n \"0.450739\",\n \"0.4507077\",\n \"0.45051634\",\n \"0.44965267\",\n \"0.44945085\",\n \"0.4492598\",\n \"0.44911635\",\n \"0.44904253\",\n \"0.44824722\",\n \"0.44788268\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7567411"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20155,"cells":{"query":{"kind":"string","value":"Returns a histogram over all relationships in a graph"},"document":{"kind":"string","value":"def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))","def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses","def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))","def get_all_relations(graph, u, v):\n return {\n data[RELATION]\n for data in graph.edge[u][v].values()\n }","def PlotDirectedEdgeHistogram(self, g, edgeAttribute=\"weight\", useLogP1Space=True):\n\t\tseries = []\n\t\tfor e in g.es:\n\t\t\tsrc = g.vs[e.source][\"name\"]\n\t\t\tdest = g.vs[e.target][\"name\"]\n\t\t\tif useLogP1Space:\n\t\t\t\tedgeValue = np.log(e[edgeAttribute])+1 #add one, simply for plotting\n\t\t\telse:\n\t\t\t\tedgeValue = e[edgeAttribute]\n\t\t\tpair = (src+\"--\"+dest, edgeValue)\n\t\t\tseries.append(pair)\n\t\t\n\t\tprint(str(series))\n\t\tdf = pd.Series([pair[1] for pair in series], index=[pair[0] for pair in series])\n\t\tprint(str(df))\n\t\tprint(\"Plotting...\")\n\t\tdf.sort_values().plot(kind='bar',title=\"Log-Space Host-Host Flow Frequency\")\n\t\t#hist.plot()\n\t\tplt.tight_layout()\n\t\tplt.show()\n\t\tplt.clf()\n\t\t\n\t\t#plot outgoing flow distributions, only for vertices with more than one outgoing edge\n\t\tfor v in g.vs:\n\t\t\tedges = g.es.select(_source=v.index)\n\t\t\tif len(edges) > 1:\n\t\t\t\tprint(str(len(edges)))\n\t\t\t\tneighborFrequencies = [(g.vs[e.target][\"name\"], e[\"weight\"]) for e in edges]\n\t\t\t\tprint(\"NEIGHBORS: \"+str(neighborFrequencies))\n\t\t\t\tseries = pd.Series([pair[1] for pair in neighborFrequencies], index=[pair[0] for pair in neighborFrequencies])\n\t\t\t\tseries.sort_values().plot(kind='bar',title=v[\"name\"]+\" Neighbor Flow Frequency\")\n\t\t\t\tplt.tight_layout()\n\t\t\t\tplt.show()\n\t\t\t\tplt.clf()","def relationships(self):","def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\n -> typ.Dict[str, int]:\n hist = collections.Counter()\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\n return hist","def cassandra_histograms(mycluster=RING_1_dev__allnodes):\n cassandra_nodetool(mycluster,cmd=\"cfhistograms\")","def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2","def Test_Histogram(Graph_MD):\n \n Edges = NX.edges(Graph_MD)\n KnotenNamen = NX.nodes(Graph_MD)\n \n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\n NumKnotenListe = len(KnotenNamenListe)\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\n \n count = 0\n for Knoten in KnotenLeitung:\n KnotenLeitung[count] = 0\n count = count + 1\n \n \n for ii in list(range(NumKnotenListe)):\n KnotenName = KnotenNamenListe[ii]\n for edge in Edges:\n posS = edge[0] == KnotenName\n posE = edge[1] == KnotenName\n \n if posS :\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n if posE:\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n \n MaxKnotenLeitung = max(KnotenLeitung)\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\n \n for ii in list(range(0, MaxKnotenLeitung + 1)):\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\n\n\n return HistSegmKnoten","def graph(self) -> dict:\n return self.flat_graph()","def bins(G):\n bins = {}\n for i in range(0, len(G.nodes(\"binary\")[0])+1):\n bins[i] = []\n\n for node in range(len(list(G.nodes()))):\n node_attr = G.node[node]\n # Calculate the level of each node\n level = node_attr[\"binary\"].count(\"1\")\n bins[level].append(node)\n\n return bins","def read_graph(args):\n dataset = pd.read_csv(args.features_path).values.tolist()\n edges = {}\n edges[\"positive_edges\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\n edges[\"negative_edges\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\n edges[\"ecount\"] = len(dataset)\n edges[\"ncount\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\n return edges","def populate_graph(self):","def adjList(self, relations):\n adj = {}\n for agent in self.agents:\n adj[agent] = {}\n for agent in self.agents:\n for relation in relations[agent]:\n if relation[0] not in adj[agent].keys():\n adj[agent][relation[0]] = []\n adj[agent][relation[0]].append(relation[1])\n return adj","def graph(self):\n ...","def hog_histograms(*args, **kwargs): # real signature unknown\n pass","def _get_full_graph(self):","def table_graph(self, i):\n return self.__graph_list[i]","def findAllVisitRelationships(tx):\n query = (\n \"MATCH (n1:Person)-[r:VISIT]->(n2:Location) \"\n \"RETURN ID(n1) , r , r.date , r.start_hour , r.end_hour , ID(n2);\"\n )\n results = tx.run(query).data()\n return results","def generate_formula_histogram(self):\n\n histogram = dict()\n for element in self.atomelements:\n if element in histogram.keys():\n histogram[element] += 1\n else:\n histogram[element] = 1\n return histogram","def get_all_edges(self):\n sum = 0\n for vertex in self:\n sum += vertex.get_edges()\n return sum","def describe_graph(g):\n print(\"Order: {} nodes\".format(g.number_of_nodes()))\n print(\"Max node id: {}\".format(max([n for n in g.nodes()])))\n print(\"Size: {} edges (interactions)\".format(g.number_of_edges()))\n print(\"Density: {}\".format(nx.density(g)))\n ts = nx.get_edge_attributes(g, 'start')\n ds = nx.get_edge_attributes(g, 'duration')\n print(\"First timestamp is: {}\".format(min(ts.values())))\n print(\"Last timestamp is: {}\".format(max([ts[k] + ds[k] for k in ts.keys()])))","def histogram_edges(edges: typ.List[typ.Tuple[int, int, int]], granularity: int=None) -> typ.List[int]:\n if len(edges) == 0:\n return list()\n if granularity is None:\n granularity = vtna.data_import.infer_update_delta(edges)\n histogram = [len(ls) for ls in vtna.data_import.group_edges_by_granularity(edges, granularity)]\n return histogram","def adjacency(graph, directed=False, reverse=False, stochastic=False, heuristic=None):\n \n v = {}\n for n in graph.nodes:\n v[n] = {}\n \n for e in graph.edges:\n id1, id2 = e\n if reverse:\n id1, id2 = reversed(e)\n \n v[id1][id2] = 1.0 - graph.edges[e].get('weight', 1.0) * 0.5\n \n if heuristic:\n v[id1][id2] += heuristic(id1, id2)\n \n if not directed:\n v[id2][id1] = v[id1][id2]\n \n if stochastic:\n for id1 in v:\n d = sum(v[id1].values())\n for id2 in v[id1]:\n v[id1][id2] /= d\n \n return v","def gen_graph(self):","def in_degree_distribution(graph):\n in_degrees = collections.Counter()\n for node in graph.nodes(data=True):\n in_degrees[graph.in_degree(node[0])] += 1\n\n in_degrees = sorted(in_degrees.items(), key=lambda x: x[0])\n\n print(in_degrees)","def get_indegrees(graph: Graph):\n transpose = get_transpose_graph(graph)\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}","def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def connected_components(graph):\n graphCopy = graph.copy()\n edges = graph.edges(data=True)\n edgeCapacity = 1.0 * np.array([property['capa'] for node1, node2, property in edges])\n percentile = np.percentile(edgeCapacity, 50.0)\n for node1, node2, property in edges:\n if property['capa'] <= percentile:\n graphCopy.remove_edge(node1, node2)\n connectedComponents = nx.connected_components(graphCopy)\n connectedComponentSizes = np.array([len(component) for component in connectedComponents])\n return(connectedComponentSizes)","def histogram(self):\n return self._hist","def hist_of_numeric(X):\n figsize(10,3)\n for col in get_numeric(X):\n print(col)\n X[col].hist(bins=50)\n show()","def connectivity_graph(rdm):\n rdm = _rd_chem.AddHs(rdm)\n atms = rdm.GetAtoms()\n bnds = rdm.GetBonds()\n asbs = dict(enumerate((rda.GetSymbol(), 0, None) for rda in atms))\n cnns = {frozenset([rdb.GetBeginAtomIdx(), rdb.GetEndAtomIdx()]): (1, None)\n for rdb in bnds}\n return (asbs, cnns)","def graph():\n\n graph = {'A': ['B', 'C'],\n 'B': ['C', 'D'],\n 'C': ['D'],\n 'D': ['C'],\n 'E': ['F'],\n 'F': ['C']}\n\n def generate_edges(graph):\n \"\"\" Convert the dict representation of a graph into a list one\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\n \"\"\"\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges\n\n a = generate_edges(graph=graph)\n print(a)","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def size(self):\n return len(self._relationships)","def graphs(self):\n return self.__graphs","def test_graph_histogram_of_sentiment_scores_on_link_ids():\n graph_histogram_of_sentiment_scores_on_link_ids('politics_30_months_comments_cleaned_standardized_vader_flair.csv')","def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\"rel\"):\n s, o = int(s.id), int(o.id)\n yield {\"predicate\": p,\n \"subject\": s,\n \"subject_nodes\": list(self.get_descendants(s, triples)),\n \"object\": o,\n \"object_nodes\": list(self.get_descendants(o, triples)),\n }","def __init__(self, network):\n self.network = network\n self.histogram = [0] * (network.maxDegree() + 1)\n\n for key, node in network.nodes.items():\n self.histogram[node.degree()] += 1\n\n #print(\"Debug: histogram list \", self.histogram)\n\n # Other option:\n # Dict containing {id:degree}\n # self.degrees = {}\n # for node in network.nodes.iteritems():\n # self.degrees[node.identifier] = node.degree()\n # for i in range(0, network.maxDegree() + 1:\n # self.histogram[i] = self.degrees.values().count(i)","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def iGraphFromTuples(association_tuples):\n \n# #get unique words\n# vocab = set()\n# uppercase_tuples = []\n# for (s,r), stren in association_tuples:\n# uppercase_tuples.append((s.upper(), r.upper(), stren))\n# vocab.update(word_pair)\n \n# vocab = list(vocab) #convert to ordered list\n# \n# \n# graph = Graph(len(vocab), directed=True)\n# graph.vs[\"name\"] = vocab #set vertex names\n# edges, _ = zip(*association_tuples)\n# graph.add_edges(edges)\n #association_tuples = [(s.upper(),r.upper(),stren) for (s,r), stren in association_tuples]\n association_tuples = [(s,r,stren) for (s,r), stren in association_tuples]\n graph = Graph.TupleList(association_tuples, directed=True, weights=True)\n \n graph.vs[\"id\"] = graph.vs[\"name\"]\n \n #add weights\n# for s, r , stren in association_tuples:\n# graph[(s,r)] = stren\n neg_log_proportions = []\n for e in graph.es:\n neg_log_proportions.append(-log10(e[\"weight\"]))\n \n graph.es[\"-log weight\"] = neg_log_proportions\n \n assoc_object = AssociationIGraph()\n assoc_object.graph = graph\n return assoc_object","def edges(self):\n return self.dovetails + self.containments + self.internals","def relations(self):\n return set(self.triples()[\"relation\"])","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n edges.append({vertex, neighbour})\n return edges","def plot_hist(self):\n labels = [self.get_class_str(action, obj)\n for (action, obj, subj, rec, beg, end) in self.action_clips]\n visualize.plot_hist(labels, proportion=True)","def degree_histogram_directed(G, in_degree=False, out_degree=False):\n nodes = G.nodes()\n if in_degree:\n in_degree = dict(G.in_degree())\n degseq=[in_degree.get(k,0) for k in nodes]\n elif out_degree:\n out_degree = dict(G.out_degree())\n degseq=[out_degree.get(k,0) for k in nodes]\n else:\n degseq=[v for k, v in G.degree()]\n dmax=max(degseq)+1\n freq= [ 0 for d in range(dmax) ]\n for d in degseq:\n freq[d] += 1\n return freq","def graph_histogram_of_sentiment_scores_on_link_ids(input_file_name):\n subreddit_name = input_file_name.split('_')[0]\n nbins = 250\n df = get_avg_sentiment_scores_on_link_id_df(input_file_name)\n\n list_of_columns_to_be_graphed = ['avg_vader_compound_score', 'avg_vader_negative_score', 'avg_vader_neutral_score',\n 'avg_vader_positive_score', 'avg_whole_comment_sentiment_flair']\n fig3 = go.Figure()\n fig3.add_trace(go.Histogram(x=df['avg_vader_compound_score'], name='avg_vader_compound_score', nbinsx=nbins))\n fig3.add_trace(go.Histogram(x=df['avg_vader_negative_score'], name='avg_vader_negative_score', nbinsx=nbins))\n fig3.add_trace(go.Histogram(x=df['avg_vader_neutral_score'], name='avg_vader_neutral_score', nbinsx=nbins))\n fig3.add_trace(go.Histogram(x=df['avg_vader_positive_score'], name='avg_vader_positive_score', nbinsx=nbins))\n fig3.add_trace(\n go.Histogram(x=df['avg_whole_comment_sentiment_flair'], name='avg_whole_comment_sentiment_flair', nbinsx=nbins))\n\n fig3.update_layout(barmode='overlay',\n bargap=.05,\n title_text='Histogram of sentiment values for\\n' +\n str(len(df)) + ' submissions in /r/' + subreddit_name + ' from May 2018 to Oct 2020')\n fig3.update_traces(opacity=0.65)\n fig3.show()","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def relations(cls):\n return [c.key for c in cls.__mapper__.iterate_properties\n if isinstance(c, RelationshipProperty)]","def increasing_cover_relations(self):\n relations = []\n size = self.size()\n for i in range(1, size):\n for j in range(i + 1, size + 1):\n if self.le(i, j):\n relations.append((i, j))\n break\n return relations","def relationship_count(self, r_type=None, n_ids=()):\n if r_type is None and not n_ids:\n return len(self._relationships)\n elif not n_ids:\n return len(self._relationships_by_type.get(r_type, ()))\n else:\n return sum(1 for _ in self.relationships(r_type, n_ids))","def rdf(bin_edges, r, V):\n N = r.shape[0]\n bin_centres = 0.5 * (bin_edges[1:] + bin_edges[:-1])\n bin_sizes = bin_edges[1:] - bin_edges[:-1]\n n = np.zeros_like(bin_sizes)\n for i in range(N):\n if i % 1000 == 0:\n print(f\"Binning {i} of {N} distances, {100*(i/N):11.3f}% commplete\")\n dr = np.linalg.norm(r - r[i], axis=1) # Distances from atom i.\n n += np.histogram(dr, bins=bin_edges)[0] # Count atoms within each\n # distance interval.\n n[0] = 0\n \n # Equation (7) on the preceding page:\n rdf = V / N**2 * n / (4 * np.pi * bin_centres**2 * bin_sizes)\n return rdf","def create_graph(users, friend_counts):\n ###TODO-- Completed\n G = nx.Graph()\n\n #For Filtering the Nodes\n #print(friend_counts)\n friend_nodes = [friend for friend in friend_counts if friend_counts[friend] > 1]\n candidate_nodes = [user['screen_name'] for user in users]\n\n #print(\"Nodes: \",len(friend_nodes), len(candidate_nodes))\n #Adding Nodes to graph\n G.add_nodes_from(friend_nodes + candidate_nodes)\n\n #Connecting the Nodes with Edges\n for candidate in users:\n for friend in friend_nodes:\n if friend in candidate['friends']:\n G.add_edge(candidate['screen_name'], friend)\n\n return G","def graph_dict2graph(self, graph_dict):\n\t\tno2index = {}\t\t#used to keep track of whether one node has appeared or not\n\t\tindex2no = {}\n\t\tgraph = Graph.Graph()\n\t\tno_of_genes = 0\n\t\tfor (edge, weight) in graph_dict.iteritems():\n\t\t\tif edge[0] not in no2index:\n\t\t\t\tindex1 = no_of_genes\n\t\t\t\tno2index[edge[0]] = index1\t\t\t\t\n\t\t\t\tindex2no[index1] = edge[0]\n\t\t\t\tno_of_genes += 1\n\t\t\telse:\n\t\t\t\tindex1 = no2index[edge[0]]\n\t\t\t\t\n\t\t\tif edge[1] not in no2index:\n\t\t\t\tindex2 = no_of_genes\n\t\t\t\tno2index[edge[1]] = index2\n\t\t\t\tindex2no[index2] = edge[1]\n\t\t\t\tno_of_genes += 1\n\t\t\telse:\n\t\t\t\tindex2 = no2index[edge[1]]\n\t\t\tif index1<index2:\n\t\t\t\tgraph.add_edge(index1, index2, weight)\n\t\t\telse:\n\t\t\t\tgraph.add_edge(index2, index1, weight)\n\t\t\n\t\treturn (index2no, graph)","def edges(self, irc, msg, args, channel):\n pie = self.instances[irc.network]\n irc.reply([str(x) for x in pie.graphs[channel].edges.values()])","def visualise_relationships(self, collection):\n author_content = {}\n\n for document, content in collection.document_map.iteritems():\n spam_set = content.loc[content['class'] == 'Spam']\n author_content[document] = spam_set['author']\n\n self.term_visualisation(collection.document_map)\n self.url_visualisation(collection.document_map)\n self.date_visualisation(collection.document_map)\n self.time_visualisation(collection.document_map)\n self.author_visualisation(author_content)","def findAllInfectedRelationships(tx):\n query = (\n \"MATCH (n1:Person)-[r:COVID_EXPOSURE]->(n2:Person) \"\n \"RETURN ID(n1) , r , r.date , r.name , ID(n2);\"\n )\n results = tx.run(query).data()\n return results","def vertex_graph(entities):\n graph = nx.Graph()\n closed = []\n for index, entity in enumerate(entities):\n if entity.closed:\n closed.append(index)\n else:\n graph.add_edges_from(entity.nodes,\n entity_index=index)\n return graph, np.array(closed)","def graph_summary(tag, graph, qubo):\n vertices = np.unique(np.array([i for i in graph]).flatten())\n neighbors = {v: 0 for v in vertices}\n for i in graph:\n neighbors[i[0]] += 1\n neighbors[i[1]] += 1\n params = dict()\n params[\"tag\"] = tag\n params[\"total_vertices\"] = len(vertices)\n params[\"total_edges\"] = len(graph)\n try:\n keylist = np.unique(np.array([key for key in qubo]).flatten())\n params[\"total_qubits\"] = len(keylist)\n except:\n params[\"total_qubits\"] = len(qubo.todense().tolist())\n params[\"max_edges\"] = max(neighbors.values())\n params[\"adjacency\"] = [list(i) for i in list(graph)]\n params[\"adjacency_hash\"] = hashlib.md5(\n str(np.sort(list(graph))).replace(\" \", \"\").encode(\"utf-8\")\n ).hexdigest()\n return params","def get_relationships(links, distances, kernel_size):\n half_k = int(kernel_size / 2)\n\n # Scale links by distances\n # links = links * distances\n\n # [batch, seq_len-1, network_size+1]\n old_pairs_rel = torch.cat([links, distances], dim=2)\n\n # Zero pad on either end of num_adj_pairs dim\n pairs_rel = F.pad(old_pairs_rel, (0, 0, half_k, half_k), \"constant\", 0.0)\n\n # Unfold to shape [batch_size, seq_len, network_size+1, kernel_size]\n out = pairs_rel.unfold(dimension=1, size=kernel_size, step=1)\n\n # Split in half. Both shape [seq_len, network_size+1, kernel_size/2]\n out_prev = out[:, :, :, :half_k]\n out_after = out[:, :, :, half_k:]\n\n # Cumulative sum to get relationships. Shape [batch, seq_len, network_size+1, kernel_size/2]\n # For words before, flip and make negative before cumsum as want reverse relationships\n dis_prev = torch.flip(torch.cumsum(torch.flip(-out_prev, dims=[3]), dim=3), dims=[3])\n dis_after = torch.cumsum(out_after, dim=3)\n\n # Join a row of zeros in middle for weightings on each word's own embedding.\n # [batch, seq_len, (kernel_size/2)+1]\n dis_prev = F.pad(dis_prev, (0, 1), \"constant\", 0.0)\n\n # Rejoin into one tensor of shape [batch_size, seq_len, network_size+1, kernel_size+1]\n dis = torch.cat([dis_prev, dis_after], dim=3)\n\n # Tranpose to [batch, seq_len, kernel_size+1, network_size+1]\n dis = dis.transpose(2, 3)\n\n # Relationships. [batch, seq_len, kernel_size+1, network_size]\n rels = dis[:, :, :, :-1]\n\n # Weights are 1 minus the distance. [batch, seq_len, kernel_size+1]\n weights = torch.clamp(1.0 - torch.abs(dis[:, :, :, -1]), min=0.0)\n\n return rels, weights","def get_neighbors(graph):\n neighbor_dict = dict()\n for node in graph:\n neighbor_dict[node] = set(graph[node])\n return neighbor_dict","def get_edges(self, topogramId):\n return self.make_request(\"GET\", \"topograms/\"+topogramId+\"/edges\", {})","def graph(self):\n graph = nx.DiGraph()\n for name, joint in self.joints.items():\n graph.add_edge(*joint.connects, joint=name)\n return graph","def generate_graph(self):\n\t\tif self.joins == None:\n\t\t\tself.get_joins()\n\t\tprint('generating Networkx DiGraph object of {database} from query results'.format(**self.__dict__))\n\t\t# save distinct Child column values\n\t\tchilds = set([j.Child for j in self.joins])\n\t\t# save distinct Parent column values\n\t\tparents = set([j.Parent for j in self.joins])\n\t\t# save names of Leaf tables\n\t\tleafs = list(childs - parents)\n\t\tself._traverse_joins(leafs)","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def relationship_types(self):\n return frozenset(self._relationships_by_type.keys())","def graph(g):\n return str(g.adjacencyList())","def ngraphs(self):\n return len(self.__graph_list)","def findAllAppContactRelationships(tx):\n query = (\n \"MATCH (n1:Person)-[r:APP_CONTACT]->(n2:Person) \"\n \"RETURN ID(n1) , r , r.date , r.hour, ID(n2);\"\n )\n results = tx.run(query).data()\n return results","def relationship_views(self) -> Iterable[RelationshipView]:\n return set(self._relationship_views)","def analyze_edges_and_weight(list_of_nodes):\n edges_info = []\n for node in list_of_nodes:\n n_edge_of_node = len(node.neighbors) # Counts the kys in the dictionary 'Node.neighbors'\n total_weight_of_node = sum(list(map(lambda x: node.neighbors[x], node.neighbors))) # Sums values of the dict\n node_info = (node.name, n_edge_of_node, total_weight_of_node)\n edges_info.append(node_info)\n total_n_edges = sum([tup[1] for tup in edges_info]) # Sum total number of edges\n total_weight_of_graph = sum([tup[2] for tup in edges_info]) # Sum total weight of edges\n sorted_info = sorted(edges_info, key=lambda tup: tup[1], reverse=True)\n return \"Total number of edges is {},\\nTotal weight of the graph is {}:\\nNodes sorted by no. of edges: {}.\".format(total_n_edges, total_weight_of_graph, sorted_info)","def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\n frame_list = []\n for idx in range(n_proteomes):\n with mailbox_reader(idx) as file_handle:\n frame_list.append(\n pd.read_csv(\n file_handle, sep=\"\\t\", index_col=0\n ).convert_dtypes()\n )\n nodes = pd.concat(\n frame_list,\n ignore_index=True,\n )\n del frame_list\n graph = nx.Graph()\n for unused_tuple, subframe in nodes.groupby(\n by=[\"syn.anchor.id\", \"syn.anchor.sub_id\"]\n ):\n ids = subframe[\"member_ids\"]\n n_ids = len(ids)\n graph.add_nodes_from(ids)\n if n_ids > 1:\n edges = combinations(ids, 2)\n graph.add_edges_from(edges, weight=n_ids)\n outpath = set_path / ANCHORS_FILE\n summarypath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_summary.tsv\"\n )\n histpath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_hist.tsv\"\n )\n components = [\n c\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\n if len(c) > 1\n ]\n fh = outpath.open(\"w\")\n fh.write(\"idx\\tcluster_id\\tsize\\tmembers\\n\")\n n_items = 0\n count_list = []\n hash_list = []\n id_list = []\n for i, comp in enumerate(components):\n component = np.sort(pd.Index(list(comp)).to_numpy())\n id_list.append(i)\n size = len(comp)\n count_list.append(size)\n hash_list.append(hash_array(component))\n for node in component:\n fh.write(f\"{n_items}\\t{i}\\t{size}\\t{node}\\n\")\n n_items += 1\n fh.close()\n n_clusts = len(count_list)\n del graph, components\n cluster_counts = pd.DataFrame({\"size\": count_list})\n largest_cluster = cluster_counts[\"size\"].max()\n cluster_hist = (\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\n )\n cluster_hist = cluster_hist.set_index(\"size\")\n cluster_hist = cluster_hist.rename(columns={0: \"n\"})\n cluster_hist[\"item_pct\"] = (\n cluster_hist[\"n\"] * cluster_hist.index * 100.0 / n_items\n )\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n cluster_hist[\"cluster_pct\"] = cluster_hist[\"n\"] * 100.0 / n_clusts\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n clusters = pd.DataFrame(\n {\"anchor.id\": id_list, \"count\": count_list, \"hash\": hash_list}\n )\n clusters.to_csv(summarypath, sep=\"\\t\")\n stats_dict = {\n \"in_anchor\": n_items,\n \"syn.anchors.n\": n_clusts,\n \"syn.anchors.largest\": largest_cluster,\n }\n return stats_dict","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def in_degree_distribution(digraph):\r\n indegree_dict = compute_in_degrees(digraph)\r\n indegree_distribution = dict()\r\n for bin_indegree in indegree_dict.values():\r\n #bin_indegree = len(adjacent_nodes)\r\n if bin_indegree in indegree_distribution.keys():\r\n indegree_distribution[bin_indegree] = indegree_distribution[bin_indegree] + 1\r\n else:\r\n indegree_distribution.update({bin_indegree: 1})\r\n\r\n return indegree_distribution","def _generate_interaction_histogram(interactions, num_users, num_items):\n histogram = np.zeros(num_items)\n np.add.at(histogram, interactions, 1)\n # Check that there's one interaction per user\n if histogram.sum() != num_users:\n raise ValueError(\"The sum of interactions must be equal to the number of users\")\n return histogram","def plot_pol_edge_counts(double_pol):\n pol_subs = load_pol_subs()\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\','')\n subreddits = pol_subs.subreddit\n pol_subs = pol_subs.set_index('subreddit')\n \n el = double_pol[['source','target','resid']]\n el_copy = el.copy()\n el_copy.columns = ['target','source','resid']\n\n pe = pd.concat([el,el_copy])\n pol_subs['num_pol_edges'] = pe.source.value_counts()\n pol_subs = pol_subs.sort_values('num_pol_edges',ascending=True)\n pol_subs['num_pol_edges'].plot(kind='barh',color=pol_subs['col'])\n\n plt.xticks(np.arange(0, 22, 2.0))\n plt.tight_layout()\n plt.savefig(figures_path(f\"{date}/pol_edge_counts.png\"))","def graph_fo_relation(self, universe):\n return FO_Relation([tuple(row) for row in self.table()], universe)","def flat_graph(self) -> dict:\n return self._pg.flat_graph()","def graph_diameter(variables, relations):\n diams = []\n g = as_networkx_graph(variables, relations)\n components = (g.subgraph(c).copy() for c in nx.connected_components(g))\n for c in components:\n diams.append(nx.diameter(c))\n\n return diams","def represent_graph(graph, n):\n \n fig, ax = plt.subplots()\n \n # Graphical representation : \n # each vertex define the absciss\n all_x = graph.keys()\n # ordinate is a random number between 0 and n \n all_y = n*np.random.rand(n)\n\n for vertex in graph:\n # for each vertex in the graph\n # get its coordinate \n x = vertex\n y = all_y[x]\n \n # represent it\n represent_vertex(ax, x, y)\n \n # get its neighbours\n neighbours = Neighbours(graph, vertex)\n \n for neighbour in neighbours :\n # for each neighbour of the vertex\n # draw an array from the vertex to its neighbour\n x_neighbour, y_neighbour = neighbour, all_y[neighbour]\n represent_link(ax, x, y, x_neighbour, y_neighbour)\n \n # Definition of the window\n plt.xlim(0,n)\n plt.ylim(0,n)\n plt.title('Graph')\n \n # Save the picture in Graph.png\n plt.savefig('Graph.png')\n plt.show()\n \n #return the graphical representation used\n return all_x, all_y","def hypergraph_common_edges(u, v, hypergraph):\n total = 0\n for e in hypergraph.edges():\n if u in e.elements and v in e.elements:\n total += 1\n return total","def test_graph_histogram_of_sentiment_scores_all_comments():\n graph_histogram_of_sentiment_scores_all_comments('politics_30_months_comments_cleaned_standardized_vader_flair.csv')","def get_node_balances(graph):\n from_nodes = graph.keys()\n to_nodes = graph.values()\n\n balances = {}\n\n for key in from_nodes:\n from_count = len(graph[key])\n\n to_count = sum([1 for x in to_nodes if key in x])\n\n balances[key] = to_count - from_count\n\n return balances","def plot_graph(self) -> None:","def getHistogram(self, var, idx = None, translation = None, other = None,\\\n verbose = 1, ab = [], bins = 100, minmax = None):\n \n if idx is None: idx = np.arange(self.atoms.shape[0])\n if translation is None: translation = [0]\n if isinstance(translation, (int, np.integer)): translation = [translation]\n\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\n verbose = verbose, ab = ab, other = other)\n x = []\n y = []\n for i, item in enumerate(data):\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\n x.append((bin[:-1] + bin[1:]) / 2)\n y.append(cnt)\n\n return x, y, lbl, leg","def draw_relationships(file_contents, emph=list(), ignore=[\"key_id_org\"],\n title=\"\", font_size=14.0, width=16.54, height=11.69):\n if len(emph) > len(misc.BREWER_SET1):\n raise PyOrganismError(\"number of objects to be emphasized ({0:d}) is\"\\\n \" greater than the number of colours available ({1:d})\",\n len(emph), len(misc.BREWER_SET1))\n pgv = misc.load_module(\"pygraphviz\")\n colour_choice = dict(itertools.izip(emph, misc.BREWER_SET1))\n graph = pgv.AGraph(name=\"RegulonDB File-Relationships\", strict=True,\n directed=False, rankdir=\"TB\")\n graph.graph_attr[\"labelloc\"] = \"t\"\n graph.graph_attr[\"label\"] = title\n graph.graph_attr[\"fontsize\"] = font_size * 1.5\n graph.graph_attr[\"ranksep\"] = \"0.1 equally\"\n graph.graph_attr[\"size\"] = (width, height)\n graph.graph_attr[\"ratio\"] = \"compress\"\n graph.node_attr[\"shape\"] = \"none\"\n graph.node_attr[\"fontsize\"] = font_size\n for (name, attrs) in file_contents.iteritems():\n label = [\"<<TABLE BORDER=\\\"0\\\" CELLBORDER=\\\"1\\\" CELLSPACING=\\\"0\\\"\"\\\n \" CELLPADDING=\\\"4\\\">\"]\n label.append(\"<TR><TD BGCOLOR=\\\"#A4A4A4\\\"><B>{0}</B></TD></TR>\".format(name))\n for (i, attr) in enumerate(attrs):\n if attr in emph:\n label.append(\"<TR><TD PORT=\\\"f{0:d}\\\" BGCOLOR=\\\"{1}\\\">{2}</TD></TR>\".format(i,\n colour_choice[attr], attr))\n else:\n label.append(\"<TR><TD PORT=\\\"f{0:d}\\\">{1}</TD></TR>\".format(i,\n attr))\n label.append(\"</TABLE>>\")\n graph.add_node(name, label=\"\\n\".join(label))\n nodes = file_contents.keys()\n for i in range(len(nodes) - 1):\n node_u = nodes[i]\n attr_u = file_contents[node_u]\n for j in range(i + 1, len(nodes)):\n node_v = nodes[j]\n attr_v = file_contents[node_v]\n shared = set(attr_u).intersection(set(attr_v))\n for attr in shared:\n if attr in ignore:\n continue\n u = attr_u.index(attr)\n v = attr_v.index(attr)\n if attr in emph:\n graph.add_edge(node_u, node_v,\n tailport=\"f{0:d}\".format(u), headport=\"f{0:d}\".format(v),\n color=colour_choice[attr])\n else:\n graph.add_edge(node_u, node_v,\n tailport=\"f{0:d}\".format(u), headport=\"f{0:d}\".format(v))\n sub_attr = dict()\n nodes = graph.nodes()\n nodes.sort(key=lambda n: graph.degree(n))\n maxi = nodes[-1: -len(nodes) / 4]\n nodes = nodes[:-len(nodes) / 4]\n zeros = [node for (node, deg) in graph.degree_iter() if deg == 0]\n for n in zeros:\n nodes.remove(n)\n graph.add_subgraph(maxi, name=\"input\", rank=\"source\", **sub_attr)\n graph.add_subgraph(nodes, name=\"middle\", **sub_attr)\n graph.add_subgraph(zeros, rank=\"sink\", **sub_attr)\n return graph","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({neighbour, vertex})\n return edges","def _get_sorted_by_n_connections(m):\n small = nx.Graph()\n for k, v in m.items():\n small.add_edge(k[0], k[1])\n return sorted(small.adj, key=lambda x: len(small[x])), small","def find_relationships(self, fig1, fig2):\r\n \r\n rels = []\r\n \r\n # relationship based on # of objects\r\n if len(fig1) == len(fig2):\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\r\n else:\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\r\n \r\n for obj, attrs in fig1.items():\r\n if not obj in fig2:\r\n # object has been removed in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\r\n continue\r\n \r\n for obj in fig2:\r\n if not obj in fig1:\r\n # object is only present in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\r\n continue\r\n \r\n for attr in fig2[obj]:\r\n rel = {'obj': obj, 'attr': attr}\r\n \r\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\r\n rel['type'] = 'match'\r\n else:\r\n partial_match = False\r\n for subvalue in fig2[obj][attr]:\r\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\r\n partial_match = True\r\n \r\n if partial_match:\r\n rel['type'] = 'partial'\r\n else:\r\n rel['type'] = 'mismatch'\r\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\r\n rel['new_values'] = ','.join(fig2[obj][attr])\r\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\r\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\r\n del rel['old_values']\r\n del rel['new_values']\r\n \r\n rels.append(rel)\r\n \r\n return rels","def plot_cc(graph):\n\tclustering_coeffs = []\n\tfor node in graph.nodes():\n\t\tclustering_coeffs.append(nx.clustering(graph, node))\n\t\n\tplt.axvline(x=np.mean(clustering_coeffs), color='r', linestyle='-')\n\tplt.hist(clustering_coeffs, bins=100)","def _CreateAdjacencyListGraph(self):\n graph = dict()\n for nodes in self.nodes:\n graph[nodes[0]] = set()\n for edges in self.edges:\n graph[edges[0]].add(edges[1])\n return graph","def create_adjacencies(graphs : List[SpatialGraph], normalize : bool = True ) -> np.ndarray:\n dtype = np.float if normalize else np.int\n return np.array([adjacency(graph, normalize) for graph in graphs], dtype=dtype)","def size(self):\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))","def histograms(self, *args, **kwargs):\n return _image.image_histograms(self, *args, **kwargs)","def findAllLiveRelationships(tx):\n query = (\n \"MATCH (n1:Person)-[r:LIVE]->(n2:House) \"\n \"RETURN ID(n1) , r , ID(n2);\"\n )\n results = tx.run(query).data()\n return results","def graph(self):\n return self.__graph","def _compute_histogram(self, individual_gradients):\n data = torch.clamp(individual_gradients, *self._range).detach().cpu().numpy()\n\n hist, edges = numpy.histogram(data, bins=self._bins, range=self._range)\n\n # convert to torch and load to device\n device = individual_gradients.device\n\n hist = torch.from_numpy(hist).to(device)\n edges = torch.from_numpy(edges).to(device)\n\n return hist, edges","def return_num_edges(self):\n return sum(map(lambda x: len(x),self.__adj))"],"string":"[\n \"def count_unique_relations(graph):\\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))\",\n \"def multiple_connections_histogram(synapses):\\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\\n return count_of_synapses\",\n \"def count_pathologies(graph):\\n return Counter(_pathology_iterator(graph))\",\n \"def get_all_relations(graph, u, v):\\n return {\\n data[RELATION]\\n for data in graph.edge[u][v].values()\\n }\",\n \"def PlotDirectedEdgeHistogram(self, g, edgeAttribute=\\\"weight\\\", useLogP1Space=True):\\n\\t\\tseries = []\\n\\t\\tfor e in g.es:\\n\\t\\t\\tsrc = g.vs[e.source][\\\"name\\\"]\\n\\t\\t\\tdest = g.vs[e.target][\\\"name\\\"]\\n\\t\\t\\tif useLogP1Space:\\n\\t\\t\\t\\tedgeValue = np.log(e[edgeAttribute])+1 #add one, simply for plotting\\n\\t\\t\\telse:\\n\\t\\t\\t\\tedgeValue = e[edgeAttribute]\\n\\t\\t\\tpair = (src+\\\"--\\\"+dest, edgeValue)\\n\\t\\t\\tseries.append(pair)\\n\\t\\t\\n\\t\\tprint(str(series))\\n\\t\\tdf = pd.Series([pair[1] for pair in series], index=[pair[0] for pair in series])\\n\\t\\tprint(str(df))\\n\\t\\tprint(\\\"Plotting...\\\")\\n\\t\\tdf.sort_values().plot(kind='bar',title=\\\"Log-Space Host-Host Flow Frequency\\\")\\n\\t\\t#hist.plot()\\n\\t\\tplt.tight_layout()\\n\\t\\tplt.show()\\n\\t\\tplt.clf()\\n\\t\\t\\n\\t\\t#plot outgoing flow distributions, only for vertices with more than one outgoing edge\\n\\t\\tfor v in g.vs:\\n\\t\\t\\tedges = g.es.select(_source=v.index)\\n\\t\\t\\tif len(edges) > 1:\\n\\t\\t\\t\\tprint(str(len(edges)))\\n\\t\\t\\t\\tneighborFrequencies = [(g.vs[e.target][\\\"name\\\"], e[\\\"weight\\\"]) for e in edges]\\n\\t\\t\\t\\tprint(\\\"NEIGHBORS: \\\"+str(neighborFrequencies))\\n\\t\\t\\t\\tseries = pd.Series([pair[1] for pair in neighborFrequencies], index=[pair[0] for pair in neighborFrequencies])\\n\\t\\t\\t\\tseries.sort_values().plot(kind='bar',title=v[\\\"name\\\"]+\\\" Neighbor Flow Frequency\\\")\\n\\t\\t\\t\\tplt.tight_layout()\\n\\t\\t\\t\\tplt.show()\\n\\t\\t\\t\\tplt.clf()\",\n \"def relationships(self):\",\n \"def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\\\\n -> typ.Dict[str, int]:\\n hist = collections.Counter()\\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\\n return hist\",\n \"def cassandra_histograms(mycluster=RING_1_dev__allnodes):\\n cassandra_nodetool(mycluster,cmd=\\\"cfhistograms\\\")\",\n \"def num_edges(g):\\n total_edges_with_duplicates = sum(len(v) for v in g.values())\\n return total_edges_with_duplicates // 2\",\n \"def Test_Histogram(Graph_MD):\\n \\n Edges = NX.edges(Graph_MD)\\n KnotenNamen = NX.nodes(Graph_MD)\\n \\n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\\n NumKnotenListe = len(KnotenNamenListe)\\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\\n \\n count = 0\\n for Knoten in KnotenLeitung:\\n KnotenLeitung[count] = 0\\n count = count + 1\\n \\n \\n for ii in list(range(NumKnotenListe)):\\n KnotenName = KnotenNamenListe[ii]\\n for edge in Edges:\\n posS = edge[0] == KnotenName\\n posE = edge[1] == KnotenName\\n \\n if posS :\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n if posE:\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n \\n MaxKnotenLeitung = max(KnotenLeitung)\\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\\n \\n for ii in list(range(0, MaxKnotenLeitung + 1)):\\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\\n\\n\\n return HistSegmKnoten\",\n \"def graph(self) -> dict:\\n return self.flat_graph()\",\n \"def bins(G):\\n bins = {}\\n for i in range(0, len(G.nodes(\\\"binary\\\")[0])+1):\\n bins[i] = []\\n\\n for node in range(len(list(G.nodes()))):\\n node_attr = G.node[node]\\n # Calculate the level of each node\\n level = node_attr[\\\"binary\\\"].count(\\\"1\\\")\\n bins[level].append(node)\\n\\n return bins\",\n \"def read_graph(args):\\n dataset = pd.read_csv(args.features_path).values.tolist()\\n edges = {}\\n edges[\\\"positive_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\\n edges[\\\"negative_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\\n edges[\\\"ecount\\\"] = len(dataset)\\n edges[\\\"ncount\\\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\\n return edges\",\n \"def populate_graph(self):\",\n \"def adjList(self, relations):\\n adj = {}\\n for agent in self.agents:\\n adj[agent] = {}\\n for agent in self.agents:\\n for relation in relations[agent]:\\n if relation[0] not in adj[agent].keys():\\n adj[agent][relation[0]] = []\\n adj[agent][relation[0]].append(relation[1])\\n return adj\",\n \"def graph(self):\\n ...\",\n \"def hog_histograms(*args, **kwargs): # real signature unknown\\n pass\",\n \"def _get_full_graph(self):\",\n \"def table_graph(self, i):\\n return self.__graph_list[i]\",\n \"def findAllVisitRelationships(tx):\\n query = (\\n \\\"MATCH (n1:Person)-[r:VISIT]->(n2:Location) \\\"\\n \\\"RETURN ID(n1) , r , r.date , r.start_hour , r.end_hour , ID(n2);\\\"\\n )\\n results = tx.run(query).data()\\n return results\",\n \"def generate_formula_histogram(self):\\n\\n histogram = dict()\\n for element in self.atomelements:\\n if element in histogram.keys():\\n histogram[element] += 1\\n else:\\n histogram[element] = 1\\n return histogram\",\n \"def get_all_edges(self):\\n sum = 0\\n for vertex in self:\\n sum += vertex.get_edges()\\n return sum\",\n \"def describe_graph(g):\\n print(\\\"Order: {} nodes\\\".format(g.number_of_nodes()))\\n print(\\\"Max node id: {}\\\".format(max([n for n in g.nodes()])))\\n print(\\\"Size: {} edges (interactions)\\\".format(g.number_of_edges()))\\n print(\\\"Density: {}\\\".format(nx.density(g)))\\n ts = nx.get_edge_attributes(g, 'start')\\n ds = nx.get_edge_attributes(g, 'duration')\\n print(\\\"First timestamp is: {}\\\".format(min(ts.values())))\\n print(\\\"Last timestamp is: {}\\\".format(max([ts[k] + ds[k] for k in ts.keys()])))\",\n \"def histogram_edges(edges: typ.List[typ.Tuple[int, int, int]], granularity: int=None) -> typ.List[int]:\\n if len(edges) == 0:\\n return list()\\n if granularity is None:\\n granularity = vtna.data_import.infer_update_delta(edges)\\n histogram = [len(ls) for ls in vtna.data_import.group_edges_by_granularity(edges, granularity)]\\n return histogram\",\n \"def adjacency(graph, directed=False, reverse=False, stochastic=False, heuristic=None):\\n \\n v = {}\\n for n in graph.nodes:\\n v[n] = {}\\n \\n for e in graph.edges:\\n id1, id2 = e\\n if reverse:\\n id1, id2 = reversed(e)\\n \\n v[id1][id2] = 1.0 - graph.edges[e].get('weight', 1.0) * 0.5\\n \\n if heuristic:\\n v[id1][id2] += heuristic(id1, id2)\\n \\n if not directed:\\n v[id2][id1] = v[id1][id2]\\n \\n if stochastic:\\n for id1 in v:\\n d = sum(v[id1].values())\\n for id2 in v[id1]:\\n v[id1][id2] /= d\\n \\n return v\",\n \"def gen_graph(self):\",\n \"def in_degree_distribution(graph):\\n in_degrees = collections.Counter()\\n for node in graph.nodes(data=True):\\n in_degrees[graph.in_degree(node[0])] += 1\\n\\n in_degrees = sorted(in_degrees.items(), key=lambda x: x[0])\\n\\n print(in_degrees)\",\n \"def get_indegrees(graph: Graph):\\n transpose = get_transpose_graph(graph)\\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}\",\n \"def compute_num_edges(graph):\\n # return the number of edges\\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def connected_components(graph):\\n graphCopy = graph.copy()\\n edges = graph.edges(data=True)\\n edgeCapacity = 1.0 * np.array([property['capa'] for node1, node2, property in edges])\\n percentile = np.percentile(edgeCapacity, 50.0)\\n for node1, node2, property in edges:\\n if property['capa'] <= percentile:\\n graphCopy.remove_edge(node1, node2)\\n connectedComponents = nx.connected_components(graphCopy)\\n connectedComponentSizes = np.array([len(component) for component in connectedComponents])\\n return(connectedComponentSizes)\",\n \"def histogram(self):\\n return self._hist\",\n \"def hist_of_numeric(X):\\n figsize(10,3)\\n for col in get_numeric(X):\\n print(col)\\n X[col].hist(bins=50)\\n show()\",\n \"def connectivity_graph(rdm):\\n rdm = _rd_chem.AddHs(rdm)\\n atms = rdm.GetAtoms()\\n bnds = rdm.GetBonds()\\n asbs = dict(enumerate((rda.GetSymbol(), 0, None) for rda in atms))\\n cnns = {frozenset([rdb.GetBeginAtomIdx(), rdb.GetEndAtomIdx()]): (1, None)\\n for rdb in bnds}\\n return (asbs, cnns)\",\n \"def graph():\\n\\n graph = {'A': ['B', 'C'],\\n 'B': ['C', 'D'],\\n 'C': ['D'],\\n 'D': ['C'],\\n 'E': ['F'],\\n 'F': ['C']}\\n\\n def generate_edges(graph):\\n \\\"\\\"\\\" Convert the dict representation of a graph into a list one\\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\\n \\\"\\\"\\\"\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\\n\\n a = generate_edges(graph=graph)\\n print(a)\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def size(self):\\n return len(self._relationships)\",\n \"def graphs(self):\\n return self.__graphs\",\n \"def test_graph_histogram_of_sentiment_scores_on_link_ids():\\n graph_histogram_of_sentiment_scores_on_link_ids('politics_30_months_comments_cleaned_standardized_vader_flair.csv')\",\n \"def get_relations(self):\\n triples = list(self.get_triples())\\n\\n for s, p, o in triples:\\n if not p.startswith(\\\"rel\\\"):\\n s, o = int(s.id), int(o.id)\\n yield {\\\"predicate\\\": p,\\n \\\"subject\\\": s,\\n \\\"subject_nodes\\\": list(self.get_descendants(s, triples)),\\n \\\"object\\\": o,\\n \\\"object_nodes\\\": list(self.get_descendants(o, triples)),\\n }\",\n \"def __init__(self, network):\\n self.network = network\\n self.histogram = [0] * (network.maxDegree() + 1)\\n\\n for key, node in network.nodes.items():\\n self.histogram[node.degree()] += 1\\n\\n #print(\\\"Debug: histogram list \\\", self.histogram)\\n\\n # Other option:\\n # Dict containing {id:degree}\\n # self.degrees = {}\\n # for node in network.nodes.iteritems():\\n # self.degrees[node.identifier] = node.degree()\\n # for i in range(0, network.maxDegree() + 1:\\n # self.histogram[i] = self.degrees.values().count(i)\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def iGraphFromTuples(association_tuples):\\n \\n# #get unique words\\n# vocab = set()\\n# uppercase_tuples = []\\n# for (s,r), stren in association_tuples:\\n# uppercase_tuples.append((s.upper(), r.upper(), stren))\\n# vocab.update(word_pair)\\n \\n# vocab = list(vocab) #convert to ordered list\\n# \\n# \\n# graph = Graph(len(vocab), directed=True)\\n# graph.vs[\\\"name\\\"] = vocab #set vertex names\\n# edges, _ = zip(*association_tuples)\\n# graph.add_edges(edges)\\n #association_tuples = [(s.upper(),r.upper(),stren) for (s,r), stren in association_tuples]\\n association_tuples = [(s,r,stren) for (s,r), stren in association_tuples]\\n graph = Graph.TupleList(association_tuples, directed=True, weights=True)\\n \\n graph.vs[\\\"id\\\"] = graph.vs[\\\"name\\\"]\\n \\n #add weights\\n# for s, r , stren in association_tuples:\\n# graph[(s,r)] = stren\\n neg_log_proportions = []\\n for e in graph.es:\\n neg_log_proportions.append(-log10(e[\\\"weight\\\"]))\\n \\n graph.es[\\\"-log weight\\\"] = neg_log_proportions\\n \\n assoc_object = AssociationIGraph()\\n assoc_object.graph = graph\\n return assoc_object\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def relations(self):\\n return set(self.triples()[\\\"relation\\\"])\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def plot_hist(self):\\n labels = [self.get_class_str(action, obj)\\n for (action, obj, subj, rec, beg, end) in self.action_clips]\\n visualize.plot_hist(labels, proportion=True)\",\n \"def degree_histogram_directed(G, in_degree=False, out_degree=False):\\n nodes = G.nodes()\\n if in_degree:\\n in_degree = dict(G.in_degree())\\n degseq=[in_degree.get(k,0) for k in nodes]\\n elif out_degree:\\n out_degree = dict(G.out_degree())\\n degseq=[out_degree.get(k,0) for k in nodes]\\n else:\\n degseq=[v for k, v in G.degree()]\\n dmax=max(degseq)+1\\n freq= [ 0 for d in range(dmax) ]\\n for d in degseq:\\n freq[d] += 1\\n return freq\",\n \"def graph_histogram_of_sentiment_scores_on_link_ids(input_file_name):\\n subreddit_name = input_file_name.split('_')[0]\\n nbins = 250\\n df = get_avg_sentiment_scores_on_link_id_df(input_file_name)\\n\\n list_of_columns_to_be_graphed = ['avg_vader_compound_score', 'avg_vader_negative_score', 'avg_vader_neutral_score',\\n 'avg_vader_positive_score', 'avg_whole_comment_sentiment_flair']\\n fig3 = go.Figure()\\n fig3.add_trace(go.Histogram(x=df['avg_vader_compound_score'], name='avg_vader_compound_score', nbinsx=nbins))\\n fig3.add_trace(go.Histogram(x=df['avg_vader_negative_score'], name='avg_vader_negative_score', nbinsx=nbins))\\n fig3.add_trace(go.Histogram(x=df['avg_vader_neutral_score'], name='avg_vader_neutral_score', nbinsx=nbins))\\n fig3.add_trace(go.Histogram(x=df['avg_vader_positive_score'], name='avg_vader_positive_score', nbinsx=nbins))\\n fig3.add_trace(\\n go.Histogram(x=df['avg_whole_comment_sentiment_flair'], name='avg_whole_comment_sentiment_flair', nbinsx=nbins))\\n\\n fig3.update_layout(barmode='overlay',\\n bargap=.05,\\n title_text='Histogram of sentiment values for\\\\n' +\\n str(len(df)) + ' submissions in /r/' + subreddit_name + ' from May 2018 to Oct 2020')\\n fig3.update_traces(opacity=0.65)\\n fig3.show()\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def relations(cls):\\n return [c.key for c in cls.__mapper__.iterate_properties\\n if isinstance(c, RelationshipProperty)]\",\n \"def increasing_cover_relations(self):\\n relations = []\\n size = self.size()\\n for i in range(1, size):\\n for j in range(i + 1, size + 1):\\n if self.le(i, j):\\n relations.append((i, j))\\n break\\n return relations\",\n \"def relationship_count(self, r_type=None, n_ids=()):\\n if r_type is None and not n_ids:\\n return len(self._relationships)\\n elif not n_ids:\\n return len(self._relationships_by_type.get(r_type, ()))\\n else:\\n return sum(1 for _ in self.relationships(r_type, n_ids))\",\n \"def rdf(bin_edges, r, V):\\n N = r.shape[0]\\n bin_centres = 0.5 * (bin_edges[1:] + bin_edges[:-1])\\n bin_sizes = bin_edges[1:] - bin_edges[:-1]\\n n = np.zeros_like(bin_sizes)\\n for i in range(N):\\n if i % 1000 == 0:\\n print(f\\\"Binning {i} of {N} distances, {100*(i/N):11.3f}% commplete\\\")\\n dr = np.linalg.norm(r - r[i], axis=1) # Distances from atom i.\\n n += np.histogram(dr, bins=bin_edges)[0] # Count atoms within each\\n # distance interval.\\n n[0] = 0\\n \\n # Equation (7) on the preceding page:\\n rdf = V / N**2 * n / (4 * np.pi * bin_centres**2 * bin_sizes)\\n return rdf\",\n \"def create_graph(users, friend_counts):\\n ###TODO-- Completed\\n G = nx.Graph()\\n\\n #For Filtering the Nodes\\n #print(friend_counts)\\n friend_nodes = [friend for friend in friend_counts if friend_counts[friend] > 1]\\n candidate_nodes = [user['screen_name'] for user in users]\\n\\n #print(\\\"Nodes: \\\",len(friend_nodes), len(candidate_nodes))\\n #Adding Nodes to graph\\n G.add_nodes_from(friend_nodes + candidate_nodes)\\n\\n #Connecting the Nodes with Edges\\n for candidate in users:\\n for friend in friend_nodes:\\n if friend in candidate['friends']:\\n G.add_edge(candidate['screen_name'], friend)\\n\\n return G\",\n \"def graph_dict2graph(self, graph_dict):\\n\\t\\tno2index = {}\\t\\t#used to keep track of whether one node has appeared or not\\n\\t\\tindex2no = {}\\n\\t\\tgraph = Graph.Graph()\\n\\t\\tno_of_genes = 0\\n\\t\\tfor (edge, weight) in graph_dict.iteritems():\\n\\t\\t\\tif edge[0] not in no2index:\\n\\t\\t\\t\\tindex1 = no_of_genes\\n\\t\\t\\t\\tno2index[edge[0]] = index1\\t\\t\\t\\t\\n\\t\\t\\t\\tindex2no[index1] = edge[0]\\n\\t\\t\\t\\tno_of_genes += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tindex1 = no2index[edge[0]]\\n\\t\\t\\t\\t\\n\\t\\t\\tif edge[1] not in no2index:\\n\\t\\t\\t\\tindex2 = no_of_genes\\n\\t\\t\\t\\tno2index[edge[1]] = index2\\n\\t\\t\\t\\tindex2no[index2] = edge[1]\\n\\t\\t\\t\\tno_of_genes += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tindex2 = no2index[edge[1]]\\n\\t\\t\\tif index1<index2:\\n\\t\\t\\t\\tgraph.add_edge(index1, index2, weight)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tgraph.add_edge(index2, index1, weight)\\n\\t\\t\\n\\t\\treturn (index2no, graph)\",\n \"def edges(self, irc, msg, args, channel):\\n pie = self.instances[irc.network]\\n irc.reply([str(x) for x in pie.graphs[channel].edges.values()])\",\n \"def visualise_relationships(self, collection):\\n author_content = {}\\n\\n for document, content in collection.document_map.iteritems():\\n spam_set = content.loc[content['class'] == 'Spam']\\n author_content[document] = spam_set['author']\\n\\n self.term_visualisation(collection.document_map)\\n self.url_visualisation(collection.document_map)\\n self.date_visualisation(collection.document_map)\\n self.time_visualisation(collection.document_map)\\n self.author_visualisation(author_content)\",\n \"def findAllInfectedRelationships(tx):\\n query = (\\n \\\"MATCH (n1:Person)-[r:COVID_EXPOSURE]->(n2:Person) \\\"\\n \\\"RETURN ID(n1) , r , r.date , r.name , ID(n2);\\\"\\n )\\n results = tx.run(query).data()\\n return results\",\n \"def vertex_graph(entities):\\n graph = nx.Graph()\\n closed = []\\n for index, entity in enumerate(entities):\\n if entity.closed:\\n closed.append(index)\\n else:\\n graph.add_edges_from(entity.nodes,\\n entity_index=index)\\n return graph, np.array(closed)\",\n \"def graph_summary(tag, graph, qubo):\\n vertices = np.unique(np.array([i for i in graph]).flatten())\\n neighbors = {v: 0 for v in vertices}\\n for i in graph:\\n neighbors[i[0]] += 1\\n neighbors[i[1]] += 1\\n params = dict()\\n params[\\\"tag\\\"] = tag\\n params[\\\"total_vertices\\\"] = len(vertices)\\n params[\\\"total_edges\\\"] = len(graph)\\n try:\\n keylist = np.unique(np.array([key for key in qubo]).flatten())\\n params[\\\"total_qubits\\\"] = len(keylist)\\n except:\\n params[\\\"total_qubits\\\"] = len(qubo.todense().tolist())\\n params[\\\"max_edges\\\"] = max(neighbors.values())\\n params[\\\"adjacency\\\"] = [list(i) for i in list(graph)]\\n params[\\\"adjacency_hash\\\"] = hashlib.md5(\\n str(np.sort(list(graph))).replace(\\\" \\\", \\\"\\\").encode(\\\"utf-8\\\")\\n ).hexdigest()\\n return params\",\n \"def get_relationships(links, distances, kernel_size):\\n half_k = int(kernel_size / 2)\\n\\n # Scale links by distances\\n # links = links * distances\\n\\n # [batch, seq_len-1, network_size+1]\\n old_pairs_rel = torch.cat([links, distances], dim=2)\\n\\n # Zero pad on either end of num_adj_pairs dim\\n pairs_rel = F.pad(old_pairs_rel, (0, 0, half_k, half_k), \\\"constant\\\", 0.0)\\n\\n # Unfold to shape [batch_size, seq_len, network_size+1, kernel_size]\\n out = pairs_rel.unfold(dimension=1, size=kernel_size, step=1)\\n\\n # Split in half. Both shape [seq_len, network_size+1, kernel_size/2]\\n out_prev = out[:, :, :, :half_k]\\n out_after = out[:, :, :, half_k:]\\n\\n # Cumulative sum to get relationships. Shape [batch, seq_len, network_size+1, kernel_size/2]\\n # For words before, flip and make negative before cumsum as want reverse relationships\\n dis_prev = torch.flip(torch.cumsum(torch.flip(-out_prev, dims=[3]), dim=3), dims=[3])\\n dis_after = torch.cumsum(out_after, dim=3)\\n\\n # Join a row of zeros in middle for weightings on each word's own embedding.\\n # [batch, seq_len, (kernel_size/2)+1]\\n dis_prev = F.pad(dis_prev, (0, 1), \\\"constant\\\", 0.0)\\n\\n # Rejoin into one tensor of shape [batch_size, seq_len, network_size+1, kernel_size+1]\\n dis = torch.cat([dis_prev, dis_after], dim=3)\\n\\n # Tranpose to [batch, seq_len, kernel_size+1, network_size+1]\\n dis = dis.transpose(2, 3)\\n\\n # Relationships. [batch, seq_len, kernel_size+1, network_size]\\n rels = dis[:, :, :, :-1]\\n\\n # Weights are 1 minus the distance. [batch, seq_len, kernel_size+1]\\n weights = torch.clamp(1.0 - torch.abs(dis[:, :, :, -1]), min=0.0)\\n\\n return rels, weights\",\n \"def get_neighbors(graph):\\n neighbor_dict = dict()\\n for node in graph:\\n neighbor_dict[node] = set(graph[node])\\n return neighbor_dict\",\n \"def get_edges(self, topogramId):\\n return self.make_request(\\\"GET\\\", \\\"topograms/\\\"+topogramId+\\\"/edges\\\", {})\",\n \"def graph(self):\\n graph = nx.DiGraph()\\n for name, joint in self.joints.items():\\n graph.add_edge(*joint.connects, joint=name)\\n return graph\",\n \"def generate_graph(self):\\n\\t\\tif self.joins == None:\\n\\t\\t\\tself.get_joins()\\n\\t\\tprint('generating Networkx DiGraph object of {database} from query results'.format(**self.__dict__))\\n\\t\\t# save distinct Child column values\\n\\t\\tchilds = set([j.Child for j in self.joins])\\n\\t\\t# save distinct Parent column values\\n\\t\\tparents = set([j.Parent for j in self.joins])\\n\\t\\t# save names of Leaf tables\\n\\t\\tleafs = list(childs - parents)\\n\\t\\tself._traverse_joins(leafs)\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def relationship_types(self):\\n return frozenset(self._relationships_by_type.keys())\",\n \"def graph(g):\\n return str(g.adjacencyList())\",\n \"def ngraphs(self):\\n return len(self.__graph_list)\",\n \"def findAllAppContactRelationships(tx):\\n query = (\\n \\\"MATCH (n1:Person)-[r:APP_CONTACT]->(n2:Person) \\\"\\n \\\"RETURN ID(n1) , r , r.date , r.hour, ID(n2);\\\"\\n )\\n results = tx.run(query).data()\\n return results\",\n \"def relationship_views(self) -> Iterable[RelationshipView]:\\n return set(self._relationship_views)\",\n \"def analyze_edges_and_weight(list_of_nodes):\\n edges_info = []\\n for node in list_of_nodes:\\n n_edge_of_node = len(node.neighbors) # Counts the kys in the dictionary 'Node.neighbors'\\n total_weight_of_node = sum(list(map(lambda x: node.neighbors[x], node.neighbors))) # Sums values of the dict\\n node_info = (node.name, n_edge_of_node, total_weight_of_node)\\n edges_info.append(node_info)\\n total_n_edges = sum([tup[1] for tup in edges_info]) # Sum total number of edges\\n total_weight_of_graph = sum([tup[2] for tup in edges_info]) # Sum total weight of edges\\n sorted_info = sorted(edges_info, key=lambda tup: tup[1], reverse=True)\\n return \\\"Total number of edges is {},\\\\nTotal weight of the graph is {}:\\\\nNodes sorted by no. of edges: {}.\\\".format(total_n_edges, total_weight_of_graph, sorted_info)\",\n \"def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\\n frame_list = []\\n for idx in range(n_proteomes):\\n with mailbox_reader(idx) as file_handle:\\n frame_list.append(\\n pd.read_csv(\\n file_handle, sep=\\\"\\\\t\\\", index_col=0\\n ).convert_dtypes()\\n )\\n nodes = pd.concat(\\n frame_list,\\n ignore_index=True,\\n )\\n del frame_list\\n graph = nx.Graph()\\n for unused_tuple, subframe in nodes.groupby(\\n by=[\\\"syn.anchor.id\\\", \\\"syn.anchor.sub_id\\\"]\\n ):\\n ids = subframe[\\\"member_ids\\\"]\\n n_ids = len(ids)\\n graph.add_nodes_from(ids)\\n if n_ids > 1:\\n edges = combinations(ids, 2)\\n graph.add_edges_from(edges, weight=n_ids)\\n outpath = set_path / ANCHORS_FILE\\n summarypath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_summary.tsv\\\"\\n )\\n histpath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_hist.tsv\\\"\\n )\\n components = [\\n c\\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\\n if len(c) > 1\\n ]\\n fh = outpath.open(\\\"w\\\")\\n fh.write(\\\"idx\\\\tcluster_id\\\\tsize\\\\tmembers\\\\n\\\")\\n n_items = 0\\n count_list = []\\n hash_list = []\\n id_list = []\\n for i, comp in enumerate(components):\\n component = np.sort(pd.Index(list(comp)).to_numpy())\\n id_list.append(i)\\n size = len(comp)\\n count_list.append(size)\\n hash_list.append(hash_array(component))\\n for node in component:\\n fh.write(f\\\"{n_items}\\\\t{i}\\\\t{size}\\\\t{node}\\\\n\\\")\\n n_items += 1\\n fh.close()\\n n_clusts = len(count_list)\\n del graph, components\\n cluster_counts = pd.DataFrame({\\\"size\\\": count_list})\\n largest_cluster = cluster_counts[\\\"size\\\"].max()\\n cluster_hist = (\\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\\n )\\n cluster_hist = cluster_hist.set_index(\\\"size\\\")\\n cluster_hist = cluster_hist.rename(columns={0: \\\"n\\\"})\\n cluster_hist[\\\"item_pct\\\"] = (\\n cluster_hist[\\\"n\\\"] * cluster_hist.index * 100.0 / n_items\\n )\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n cluster_hist[\\\"cluster_pct\\\"] = cluster_hist[\\\"n\\\"] * 100.0 / n_clusts\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n clusters = pd.DataFrame(\\n {\\\"anchor.id\\\": id_list, \\\"count\\\": count_list, \\\"hash\\\": hash_list}\\n )\\n clusters.to_csv(summarypath, sep=\\\"\\\\t\\\")\\n stats_dict = {\\n \\\"in_anchor\\\": n_items,\\n \\\"syn.anchors.n\\\": n_clusts,\\n \\\"syn.anchors.largest\\\": largest_cluster,\\n }\\n return stats_dict\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def in_degree_distribution(digraph):\\r\\n indegree_dict = compute_in_degrees(digraph)\\r\\n indegree_distribution = dict()\\r\\n for bin_indegree in indegree_dict.values():\\r\\n #bin_indegree = len(adjacent_nodes)\\r\\n if bin_indegree in indegree_distribution.keys():\\r\\n indegree_distribution[bin_indegree] = indegree_distribution[bin_indegree] + 1\\r\\n else:\\r\\n indegree_distribution.update({bin_indegree: 1})\\r\\n\\r\\n return indegree_distribution\",\n \"def _generate_interaction_histogram(interactions, num_users, num_items):\\n histogram = np.zeros(num_items)\\n np.add.at(histogram, interactions, 1)\\n # Check that there's one interaction per user\\n if histogram.sum() != num_users:\\n raise ValueError(\\\"The sum of interactions must be equal to the number of users\\\")\\n return histogram\",\n \"def plot_pol_edge_counts(double_pol):\\n pol_subs = load_pol_subs()\\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\\\\\','')\\n subreddits = pol_subs.subreddit\\n pol_subs = pol_subs.set_index('subreddit')\\n \\n el = double_pol[['source','target','resid']]\\n el_copy = el.copy()\\n el_copy.columns = ['target','source','resid']\\n\\n pe = pd.concat([el,el_copy])\\n pol_subs['num_pol_edges'] = pe.source.value_counts()\\n pol_subs = pol_subs.sort_values('num_pol_edges',ascending=True)\\n pol_subs['num_pol_edges'].plot(kind='barh',color=pol_subs['col'])\\n\\n plt.xticks(np.arange(0, 22, 2.0))\\n plt.tight_layout()\\n plt.savefig(figures_path(f\\\"{date}/pol_edge_counts.png\\\"))\",\n \"def graph_fo_relation(self, universe):\\n return FO_Relation([tuple(row) for row in self.table()], universe)\",\n \"def flat_graph(self) -> dict:\\n return self._pg.flat_graph()\",\n \"def graph_diameter(variables, relations):\\n diams = []\\n g = as_networkx_graph(variables, relations)\\n components = (g.subgraph(c).copy() for c in nx.connected_components(g))\\n for c in components:\\n diams.append(nx.diameter(c))\\n\\n return diams\",\n \"def represent_graph(graph, n):\\n \\n fig, ax = plt.subplots()\\n \\n # Graphical representation : \\n # each vertex define the absciss\\n all_x = graph.keys()\\n # ordinate is a random number between 0 and n \\n all_y = n*np.random.rand(n)\\n\\n for vertex in graph:\\n # for each vertex in the graph\\n # get its coordinate \\n x = vertex\\n y = all_y[x]\\n \\n # represent it\\n represent_vertex(ax, x, y)\\n \\n # get its neighbours\\n neighbours = Neighbours(graph, vertex)\\n \\n for neighbour in neighbours :\\n # for each neighbour of the vertex\\n # draw an array from the vertex to its neighbour\\n x_neighbour, y_neighbour = neighbour, all_y[neighbour]\\n represent_link(ax, x, y, x_neighbour, y_neighbour)\\n \\n # Definition of the window\\n plt.xlim(0,n)\\n plt.ylim(0,n)\\n plt.title('Graph')\\n \\n # Save the picture in Graph.png\\n plt.savefig('Graph.png')\\n plt.show()\\n \\n #return the graphical representation used\\n return all_x, all_y\",\n \"def hypergraph_common_edges(u, v, hypergraph):\\n total = 0\\n for e in hypergraph.edges():\\n if u in e.elements and v in e.elements:\\n total += 1\\n return total\",\n \"def test_graph_histogram_of_sentiment_scores_all_comments():\\n graph_histogram_of_sentiment_scores_all_comments('politics_30_months_comments_cleaned_standardized_vader_flair.csv')\",\n \"def get_node_balances(graph):\\n from_nodes = graph.keys()\\n to_nodes = graph.values()\\n\\n balances = {}\\n\\n for key in from_nodes:\\n from_count = len(graph[key])\\n\\n to_count = sum([1 for x in to_nodes if key in x])\\n\\n balances[key] = to_count - from_count\\n\\n return balances\",\n \"def plot_graph(self) -> None:\",\n \"def getHistogram(self, var, idx = None, translation = None, other = None,\\\\\\n verbose = 1, ab = [], bins = 100, minmax = None):\\n \\n if idx is None: idx = np.arange(self.atoms.shape[0])\\n if translation is None: translation = [0]\\n if isinstance(translation, (int, np.integer)): translation = [translation]\\n\\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\\\\n verbose = verbose, ab = ab, other = other)\\n x = []\\n y = []\\n for i, item in enumerate(data):\\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\\n x.append((bin[:-1] + bin[1:]) / 2)\\n y.append(cnt)\\n\\n return x, y, lbl, leg\",\n \"def draw_relationships(file_contents, emph=list(), ignore=[\\\"key_id_org\\\"],\\n title=\\\"\\\", font_size=14.0, width=16.54, height=11.69):\\n if len(emph) > len(misc.BREWER_SET1):\\n raise PyOrganismError(\\\"number of objects to be emphasized ({0:d}) is\\\"\\\\\\n \\\" greater than the number of colours available ({1:d})\\\",\\n len(emph), len(misc.BREWER_SET1))\\n pgv = misc.load_module(\\\"pygraphviz\\\")\\n colour_choice = dict(itertools.izip(emph, misc.BREWER_SET1))\\n graph = pgv.AGraph(name=\\\"RegulonDB File-Relationships\\\", strict=True,\\n directed=False, rankdir=\\\"TB\\\")\\n graph.graph_attr[\\\"labelloc\\\"] = \\\"t\\\"\\n graph.graph_attr[\\\"label\\\"] = title\\n graph.graph_attr[\\\"fontsize\\\"] = font_size * 1.5\\n graph.graph_attr[\\\"ranksep\\\"] = \\\"0.1 equally\\\"\\n graph.graph_attr[\\\"size\\\"] = (width, height)\\n graph.graph_attr[\\\"ratio\\\"] = \\\"compress\\\"\\n graph.node_attr[\\\"shape\\\"] = \\\"none\\\"\\n graph.node_attr[\\\"fontsize\\\"] = font_size\\n for (name, attrs) in file_contents.iteritems():\\n label = [\\\"<<TABLE BORDER=\\\\\\\"0\\\\\\\" CELLBORDER=\\\\\\\"1\\\\\\\" CELLSPACING=\\\\\\\"0\\\\\\\"\\\"\\\\\\n \\\" CELLPADDING=\\\\\\\"4\\\\\\\">\\\"]\\n label.append(\\\"<TR><TD BGCOLOR=\\\\\\\"#A4A4A4\\\\\\\"><B>{0}</B></TD></TR>\\\".format(name))\\n for (i, attr) in enumerate(attrs):\\n if attr in emph:\\n label.append(\\\"<TR><TD PORT=\\\\\\\"f{0:d}\\\\\\\" BGCOLOR=\\\\\\\"{1}\\\\\\\">{2}</TD></TR>\\\".format(i,\\n colour_choice[attr], attr))\\n else:\\n label.append(\\\"<TR><TD PORT=\\\\\\\"f{0:d}\\\\\\\">{1}</TD></TR>\\\".format(i,\\n attr))\\n label.append(\\\"</TABLE>>\\\")\\n graph.add_node(name, label=\\\"\\\\n\\\".join(label))\\n nodes = file_contents.keys()\\n for i in range(len(nodes) - 1):\\n node_u = nodes[i]\\n attr_u = file_contents[node_u]\\n for j in range(i + 1, len(nodes)):\\n node_v = nodes[j]\\n attr_v = file_contents[node_v]\\n shared = set(attr_u).intersection(set(attr_v))\\n for attr in shared:\\n if attr in ignore:\\n continue\\n u = attr_u.index(attr)\\n v = attr_v.index(attr)\\n if attr in emph:\\n graph.add_edge(node_u, node_v,\\n tailport=\\\"f{0:d}\\\".format(u), headport=\\\"f{0:d}\\\".format(v),\\n color=colour_choice[attr])\\n else:\\n graph.add_edge(node_u, node_v,\\n tailport=\\\"f{0:d}\\\".format(u), headport=\\\"f{0:d}\\\".format(v))\\n sub_attr = dict()\\n nodes = graph.nodes()\\n nodes.sort(key=lambda n: graph.degree(n))\\n maxi = nodes[-1: -len(nodes) / 4]\\n nodes = nodes[:-len(nodes) / 4]\\n zeros = [node for (node, deg) in graph.degree_iter() if deg == 0]\\n for n in zeros:\\n nodes.remove(n)\\n graph.add_subgraph(maxi, name=\\\"input\\\", rank=\\\"source\\\", **sub_attr)\\n graph.add_subgraph(nodes, name=\\\"middle\\\", **sub_attr)\\n graph.add_subgraph(zeros, rank=\\\"sink\\\", **sub_attr)\\n return graph\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({neighbour, vertex})\\n return edges\",\n \"def _get_sorted_by_n_connections(m):\\n small = nx.Graph()\\n for k, v in m.items():\\n small.add_edge(k[0], k[1])\\n return sorted(small.adj, key=lambda x: len(small[x])), small\",\n \"def find_relationships(self, fig1, fig2):\\r\\n \\r\\n rels = []\\r\\n \\r\\n # relationship based on # of objects\\r\\n if len(fig1) == len(fig2):\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\\r\\n else:\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\\r\\n \\r\\n for obj, attrs in fig1.items():\\r\\n if not obj in fig2:\\r\\n # object has been removed in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\\r\\n continue\\r\\n \\r\\n for obj in fig2:\\r\\n if not obj in fig1:\\r\\n # object is only present in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\\r\\n continue\\r\\n \\r\\n for attr in fig2[obj]:\\r\\n rel = {'obj': obj, 'attr': attr}\\r\\n \\r\\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\\r\\n rel['type'] = 'match'\\r\\n else:\\r\\n partial_match = False\\r\\n for subvalue in fig2[obj][attr]:\\r\\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\\r\\n partial_match = True\\r\\n \\r\\n if partial_match:\\r\\n rel['type'] = 'partial'\\r\\n else:\\r\\n rel['type'] = 'mismatch'\\r\\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\\r\\n rel['new_values'] = ','.join(fig2[obj][attr])\\r\\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\\r\\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\\r\\n del rel['old_values']\\r\\n del rel['new_values']\\r\\n \\r\\n rels.append(rel)\\r\\n \\r\\n return rels\",\n \"def plot_cc(graph):\\n\\tclustering_coeffs = []\\n\\tfor node in graph.nodes():\\n\\t\\tclustering_coeffs.append(nx.clustering(graph, node))\\n\\t\\n\\tplt.axvline(x=np.mean(clustering_coeffs), color='r', linestyle='-')\\n\\tplt.hist(clustering_coeffs, bins=100)\",\n \"def _CreateAdjacencyListGraph(self):\\n graph = dict()\\n for nodes in self.nodes:\\n graph[nodes[0]] = set()\\n for edges in self.edges:\\n graph[edges[0]].add(edges[1])\\n return graph\",\n \"def create_adjacencies(graphs : List[SpatialGraph], normalize : bool = True ) -> np.ndarray:\\n dtype = np.float if normalize else np.int\\n return np.array([adjacency(graph, normalize) for graph in graphs], dtype=dtype)\",\n \"def size(self):\\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))\",\n \"def histograms(self, *args, **kwargs):\\n return _image.image_histograms(self, *args, **kwargs)\",\n \"def findAllLiveRelationships(tx):\\n query = (\\n \\\"MATCH (n1:Person)-[r:LIVE]->(n2:House) \\\"\\n \\\"RETURN ID(n1) , r , ID(n2);\\\"\\n )\\n results = tx.run(query).data()\\n return results\",\n \"def graph(self):\\n return self.__graph\",\n \"def _compute_histogram(self, individual_gradients):\\n data = torch.clamp(individual_gradients, *self._range).detach().cpu().numpy()\\n\\n hist, edges = numpy.histogram(data, bins=self._bins, range=self._range)\\n\\n # convert to torch and load to device\\n device = individual_gradients.device\\n\\n hist = torch.from_numpy(hist).to(device)\\n edges = torch.from_numpy(edges).to(device)\\n\\n return hist, edges\",\n \"def return_num_edges(self):\\n return sum(map(lambda x: len(x),self.__adj))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.69387263","0.6183445","0.6046419","0.6034515","0.59751195","0.57758623","0.57072544","0.5633479","0.5611335","0.56087476","0.55993664","0.5599142","0.55365855","0.5526105","0.54780513","0.547426","0.54703754","0.5457386","0.54382086","0.5435362","0.5413176","0.53789157","0.53737825","0.5373599","0.5351694","0.5347484","0.532761","0.53258425","0.5315799","0.53111726","0.53083116","0.53026545","0.5290813","0.52889067","0.5287346","0.5283589","0.5280251","0.52708805","0.52667314","0.5256138","0.5248591","0.5247865","0.52468616","0.523884","0.5232602","0.52305865","0.52264637","0.5218573","0.5207519","0.52037156","0.52006537","0.5196341","0.5187432","0.5185049","0.51773113","0.5173048","0.5172424","0.5169255","0.51690346","0.5167217","0.516622","0.5160264","0.5154168","0.5147521","0.5139667","0.513242","0.51292336","0.51236683","0.5109556","0.5104977","0.50940216","0.5093472","0.50920963","0.50894445","0.50845873","0.5084074","0.50795877","0.50746024","0.50716513","0.50694585","0.5067873","0.5065335","0.5058311","0.5050079","0.50492257","0.5036626","0.50307673","0.5027336","0.50253564","0.5024354","0.50234836","0.502338","0.50185305","0.50166726","0.5010378","0.50093913","0.5009109","0.50060934","0.5003858","0.500197"],"string":"[\n \"0.69387263\",\n \"0.6183445\",\n \"0.6046419\",\n \"0.6034515\",\n \"0.59751195\",\n \"0.57758623\",\n \"0.57072544\",\n \"0.5633479\",\n \"0.5611335\",\n \"0.56087476\",\n \"0.55993664\",\n \"0.5599142\",\n \"0.55365855\",\n \"0.5526105\",\n \"0.54780513\",\n \"0.547426\",\n \"0.54703754\",\n \"0.5457386\",\n \"0.54382086\",\n \"0.5435362\",\n \"0.5413176\",\n \"0.53789157\",\n \"0.53737825\",\n \"0.5373599\",\n \"0.5351694\",\n \"0.5347484\",\n \"0.532761\",\n \"0.53258425\",\n \"0.5315799\",\n \"0.53111726\",\n \"0.53083116\",\n \"0.53026545\",\n \"0.5290813\",\n \"0.52889067\",\n \"0.5287346\",\n \"0.5283589\",\n \"0.5280251\",\n \"0.52708805\",\n \"0.52667314\",\n \"0.5256138\",\n \"0.5248591\",\n \"0.5247865\",\n \"0.52468616\",\n \"0.523884\",\n \"0.5232602\",\n \"0.52305865\",\n \"0.52264637\",\n \"0.5218573\",\n \"0.5207519\",\n \"0.52037156\",\n \"0.52006537\",\n \"0.5196341\",\n \"0.5187432\",\n \"0.5185049\",\n \"0.51773113\",\n \"0.5173048\",\n \"0.5172424\",\n \"0.5169255\",\n \"0.51690346\",\n \"0.5167217\",\n \"0.516622\",\n \"0.5160264\",\n \"0.5154168\",\n \"0.5147521\",\n \"0.5139667\",\n \"0.513242\",\n \"0.51292336\",\n \"0.51236683\",\n \"0.5109556\",\n \"0.5104977\",\n \"0.50940216\",\n \"0.5093472\",\n \"0.50920963\",\n \"0.50894445\",\n \"0.50845873\",\n \"0.5084074\",\n \"0.50795877\",\n \"0.50746024\",\n \"0.50716513\",\n \"0.50694585\",\n \"0.5067873\",\n \"0.5065335\",\n \"0.5058311\",\n \"0.5050079\",\n \"0.50492257\",\n \"0.5036626\",\n \"0.50307673\",\n \"0.5027336\",\n \"0.50253564\",\n \"0.5024354\",\n \"0.50234836\",\n \"0.502338\",\n \"0.50185305\",\n \"0.50166726\",\n \"0.5010378\",\n \"0.50093913\",\n \"0.5009109\",\n \"0.50060934\",\n \"0.5003858\",\n \"0.500197\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7300097"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20156,"cells":{"query":{"kind":"string","value":"Makes a dict that accumulates the values for each key in an iterator of doubles"},"document":{"kind":"string","value":"def group_dict_set(iterator):\n d = defaultdict(set)\n for key, value in iterator:\n d[key].add(value)\n return dict(d)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def add_densities(densities):\n\n return {spin: sum(np.array(dens[spin]) for dens in densities) \n for spin in densities[0].keys()}","def build_histogram(iterator, key):\n buckets = defaultdict(int)\n values = {}\n\n num_objects = 0\n for obj in iterator:\n num_objects += 1\n\n try:\n val = obj[key]\n except (KeyError, TypeError):\n continue\n\n value_hash = hashlib.sha1()\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\n value_hash = value_hash.hexdigest()\n\n buckets[value_hash] += 1\n values[value_hash] = val\n\n return [\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\n ]","def _create_freq_dist(self):\r\n freq_dict = dict()\r\n\r\n for element in self.data:\r\n if element in freq_dict:\r\n freq_dict[element] += 1\r\n else:\r\n freq_dict[element] = 1\r\n\r\n return freq_dict","def probability(self):\r\n \r\n my_dict = dict()\r\n \r\n for i in self.__dtmc:\r\n \r\n sum_Pij = float(sum([self.__dtmc[i][j] for j in self.__dtmc[i]]))\r\n \r\n if sum_Pij == 0:\r\n \r\n my_dict[i] = dict()\r\n \r\n elif sum_Pij > 0:\r\n \r\n if i not in my_dict:\r\n \r\n my_dict[i] = dict()\r\n \r\n for j in self.__dtmc[i]:\r\n \r\n Pij = self.__dtmc[i][j] / sum_Pij\r\n \r\n my_dict[i][j] = Pij\r\n \r\n return my_dict","def collect_by_key(pair_iter):\n out = {}\n for (k, v) in pair_iter:\n out[k] = out.get(k, [])\n out[k].append(v)\n return out","def process_datapoints(datapoints):\n point_dict = {}\n\n ddata = [p for p in datapoints]\n for point in ddata:\n point_dict[hash_datapoint(point)] = {'results': [],\n 'time': [],\n 'features': point['features']}\n\n for point in ddata:\n point_dict[hash_datapoint(point)]['results'].append(point['result'])\n point_dict[hash_datapoint(point)]['time'].append(point['time'])\n\n for e in point_dict:\n result_array = np.array(point_dict[e]['results'])\n point_dict[e]['n'] = len(point_dict[e]['results'])\n point_dict[e]['mu'] = np.mean(result_array)\n point_dict[e]['sigma'] = np.std(result_array)\n del point_dict[e]['results']\n\n return point_dict","def calcRs(distances):\n r = {}\n \n for key in distances.keys():\n summedDistances = 0\n for subkey in distances[key].keys():\n summedDistances += distances[key][subkey]\n r[key] = summedDistances/(len(distances.keys())-2)\n\n return r","def daily_speed_sum_reduce(key, values):\n\tyield \"%s: %s, %s\\n\" % (key, sum([int(value) for value in values]), len(values))","def dictionary_of_metrics(items):\n\n 'Initialize dict'\n d = {}\n\n # Add 'mean' key to the dict with the value of the mean calculate by using\n # np.mean rounded to 2 decimal places\n d['mean'] = round(np.mean(items), 2)\n\n # Add 'median' key to the dict with the value of the median calculate by\n # using np.median rounded to 2 decimal places\n d['median'] = round(np.median(items), 2)\n\n # Add 'var' key to the dict with the value of the varience calculate by\n # using np.var rounded to 2 decimal places\n d['var'] = round(np.var(items, ddof=1), 2)\n\n # Add 'std' key to the dict with the value of the standard deviation\n # calculate by using np.std to 2 decimal places\n d['std'] = round(np.std(items, ddof=1), 2)\n\n # Add 'min' key to the dict with the value of the minimum calculate by\n # using np.min to 2 decimal places\n d['min'] = round(np.min(items), 2)\n\n # Add 'max' key to the dict with the value of the maximum calculate by\n # using np.max to 2 decimal places\n d['max'] = round(np.max(items), 2)\n\n # returns dictionary, d\n return d","def dict(self) -> Dict[str, List[NumericType]]:\n return {r.name: r.floats() for r in self._records}","def compute_key_value(self) -> Dict[str, float]:\n # @TODO: ddp hotfix, could be done better\n if self._is_ddp:\n for key in self.statistics:\n value: List[np.ndarray] = all_gather(self.statistics[key])\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\n self.statistics[key] = value\n\n per_class, micro, macro, weighted = self.compute()\n metrics = self._convert_metrics_to_kv(\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\n )\n return metrics","def dictionary_of_metrics(items):\n total = 0\n count = 0\n for value in items:\n total = total + value\n count = count + 1\n the_mean = round(total / count, 2)\n sorted_items = sorted(items)\n if count % 2 == 1:\n the_median = sorted_items[int(round(count+1)/2-1)]\n else:\n lower_median = sorted_items[int(round(count/2-1))]\n upper_median = sorted_items[int(round(count/2))]\n the_median = (lower_median + upper_median) / 2\n sum_of_sqz = 0 # Calculate Sum of squares for Varience\n for j in items:\n sqrz_calc = (j - the_mean)**2\n sum_of_sqz = sum_of_sqz + sqrz_calc\n the_varience = round(sum_of_sqz / (count - 1), 2)\n the_standard_dev = round((the_varience)**(1/2), 2)\n the_min = sorted_items[0]\n the_max = sorted_items[count - 1]\n dict = {\n 'mean': the_mean,\n 'median': the_median,\n 'var': the_varience,\n 'std': the_standard_dev,\n 'min': the_min,\n 'max': the_max\n }\n return dict","def compute_empirical_distribution(values):\n distribution = {}\n\n # -------------------------------------------------------------------------\n # YOUR CODE HERE\n #\n for value in values:\n if value not in distribution:\n distribution[value] = 1\n else:\n distribution[value] += 1\n \n total = len(values)\n for v in distribution.keys():\n distribution[v] /= total\n \n\n #\n # END OF YOUR CODE\n # -------------------------------------------------------------------------\n\n return distribution","def build_intermediate_dict(self) -> Dict[str, float]:\n intermediate = {}\n now = datetime.now()\n current_time = now.replace(hour=0, minute=0, second=0, microsecond=0)\n\n delta = timedelta(minutes=15)\n\n for i in range(0, 96):\n intermediate[self.date_to_intermediate_time_str(current_time)] = 0.0\n current_time = current_time + delta\n\n return intermediate","def values_to_dict(keys: tuple, values: list) -> dict:\n out = {}\n for i, key in enumerate(keys):\n out[key] = np.array([x[i] for x in values])\n return out","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['lambda'] = self.lambdaVar\n retDict['k'] = self.k\n retDict['low'] = self.low\n return retDict","def accumulate (cls, dict, inverse=False):\n total = 0\n output = {}\n keys = range(0, cls.max_key(dict) + 1)\n if inverse:\n keys = range(cls.max_key(dict), -1, -1) # Invert range if needed.\n for i in keys:\n if i in dict:\n total += dict[i] # Accumulate frequencies.\n output[i] = total\n return output","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['mu'] = self.mean\n retDict['sigma'] = self.sigma\n retDict['low'] = self.low\n return retDict","def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\n data = {}\n ts = None\n #print ts_keyname\n for parsts, parsdata in func():\n #print parsdata\n #print parsdata[\"log_timestamp\"]\n if ts is None:\n ts = parsts\n key = tuple((parsdata[key] for key in index_keynames))\n values = tuple((int(parsdata[key]) for key in value_keynames))\n if key not in data:\n data[key] = values\n else:\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\n if parsts > (ts + interval):\n for keys, values in data.items():\n yield \"%s\\t%s\\t%s\" % (ts, \"\\t\".join((str(index_key) for index_key in keys)), \"\\t\".join((str(value_key) for value_key in values)))\n ts = None\n data = {}","def associate(keys, values):\n result = {}\n val_it = iter(values)\n\n for key in keys:\n try:\n result[key] = next(val_it)\n except StopIteration:\n result[key] = None\n return result","def calc_sim_collector(self, key, values):\r\n (rest1, rest2), common_ratings = key, values\r\n\t #your code here\r\n yield (rest1, rest2), (rho, n_common)","def update_dict(self, total_dict: dict, iter_dict: dict) -> dict:\n for k in iter_dict:\n if k not in total_dict:\n total_dict[k] = iter_dict[k]\n else:\n total_dict[k] += iter_dict[k]\n \n return total_dict","def _buildTotalsDict(self, fromdt, todt):\r\n pairs = [(t, t.effectForPeriod(fromdt, todt)) for t in self.transactions]\r\n return dict(pairs)","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['mu'] = self.mean\n retDict['sigma'] = self.sigma\n return retDict","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['k'] = self.alpha\n retDict['theta'] = 1.0/self.beta\n retDict['low'] = self.low\n return retDict","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['alpha'] = self.alpha\n retDict['beta'] = self.beta\n retDict['scale'] = self.high-self.low\n retDict['low'] = self.low\n return retDict","def group_by(data, key_func=identity, value_func=identity):\n\n def reduce(dic, ele):\n k = key_func(ele)\n if k in dic:\n dic[k].append(value_func(ele))\n else:\n dic[k] = [value_func(ele)]\n return dic\n\n return functools.reduce(reduce, data, {})","def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\n hist = {k: {} for k in {\"mks0\", \"mks1\", \"mks2\", \"l\"}} # pylint: disable=C0208\n wei = {k: {} for k in hist}\n res[\"hist\"] = hist\n res[\"histnow\"] = wei\n\n for el, _ in self.enumerate_test_metric(qset):\n le = len(el.value)\n w = el.weight\n res[\"mks0\"] += w * el.mks0\n res[\"mks1\"] += w * el.mks1\n res[\"mks2\"] += w * el.mks2\n res[\"sum_weights\"] += w\n res[\"sum_wlen\"] += w * le\n res[\"n\"] += 1\n\n if el.mks0 not in hist[\"mks0\"]:\n hist[\"mks0\"][el.mks0] = w\n wei[\"mks0\"][el.mks0] = 1\n else:\n hist[\"mks0\"][el.mks0] += w\n wei[\"mks0\"][el.mks0] += 1\n if el.mks1 not in hist[\"mks1\"]:\n hist[\"mks1\"][el.mks1] = w\n wei[\"mks1\"][el.mks1] = 1\n else:\n hist[\"mks1\"][el.mks1] += w\n wei[\"mks1\"][el.mks1] += 1\n if el.mks2 not in hist[\"mks2\"]:\n hist[\"mks2\"][el.mks2] = w\n wei[\"mks2\"][el.mks2] = 1\n else:\n hist[\"mks2\"][el.mks2] += w\n wei[\"mks2\"][el.mks2] += 1\n if le not in hist[\"l\"]:\n hist[\"l\"][le] = w\n wei[\"l\"][le] = 1\n else:\n hist[\"l\"][le] += w\n wei[\"l\"][le] += 1\n return res","def reduceWith(aggregation_fn, key, values ):\n yield (key, aggregation_fn(values))","def gen_dict():\n lines = [line for line in csv.reader(open(__ppath__ + \"/data/occupations.csv\"))] # uses a csv.reader to parse the file, converts the generic iterable to a list\n lines = [(line[0],float(line[1])) for line in lines[1:-2]]# removes the column names and \"Total\" row, re-expresses as a list of tuples to enable dictionary conversion\n lines.append((\"Unemployed\",0.2)) # accounts for missing 0.2% of jobs\n return dict(lines) # converts to dictionary","def extract_data(self):\n values = {}\n for injkey in self.data_sets.keys():\n values[injkey] = {}\n alldata = self.data_sets[injkey]\n paramkeys = alldata['params'].keys()\n for datakey in alldata.keys():\n if not datakey == 'params':\n values[injkey][datakey] = {}\n values[injkey][datakey]['metric_val'] = {}\n values[injkey][datakey]['metric_val']['vals'] = []\n for paramkey in paramkeys:\n values[injkey][datakey][paramkey] = {}\n values[injkey][datakey][paramkey]['vals'] = []\n trials = alldata[datakey]\n for trial_num in trials.keys():\n trial = trials[trial_num]\n values[injkey][datakey]['metric_val']['vals'] \\\n .append(trial['metric_val'])\n values[injkey][datakey]['metric_val']['type'] \\\n = trial['metric']\n values[injkey][datakey]['metric_val']['units'] \\\n = 'dimensionless'\n param_vals = trial['params']\n for param_name in param_vals.keys():\n val, units = self.parse_pint_string(\n pint_string=param_vals[param_name]\n )\n values[injkey][datakey][param_name]['vals'] \\\n .append(float(val))\n values[injkey][datakey][param_name]['units'] \\\n = units\n self.values = values","def initDictionary(bands):\r\n for x in bands:\r\n d[\"{}\".format(x)] = {ProdCost: [], AlbumSales: []}","def convertSumsToMap(arr, values):\n num_map = {}\n for item in values:\n num_map[item] = []\n\n for i in range(len(arr)):\n num_map[i+1] = setFromValues(arr[i])\n\n return num_map","def multDic(dic, x):\n pass","def dictionary_of_metrics(items):\n \n np_list = np.array(items) #create an array of list to use numpy functions on list\n metric_dict = {'mean': np.mean(np_list).round(2),\n 'median': np.median(np_list).round(2),\n 'var': np.var(np_list, ddof=1).round(2),\n 'std': np.std(np_list, ddof=1).round(2),\n 'min': np.min(np_list).round(2),\n 'max': np.max(np_list).round(2),} #create a dictionary that calculates the five metrics\n \n return metric_dict #return result as a dictionary","def histogramintegrals(self):\n return {}","def build_coeff_dict(l):\n coeff_dict = {}\n for triplet in l:\n coeff_dict[triplet[0]] = triplet[2]\n return coeff_dict","def __iter__(self):\n key = list(self.keys())[0]\n length = len(self[key])\n for i in range(length):\n res = {}\n for key, feature in self.items():\n res[key] = feature.data[feature.name][i]\n yield res","def __iter__(self):\n prefix = len(META_NS) + 2\n for key, value in self.stats.items():\n yield (key[prefix:-6], int(value))","def summarize_data(data, summary_keys):\n summary = {}\n latest_iteration_number = len(data.keys())\n current_value = None\n\n for key in summary_keys:\n summary[key] = []\n # Compute per-iteration average of the given key.\n for i in range(latest_iteration_number):\n iter_key = '{}{}'.format(ITERATION_PREFIX, i)\n # We allow reporting the same value multiple times when data is missing.\n # If there is no data for this iteration, use the previous'.\n if iter_key in data:\n current_value = np.mean(data[iter_key][key])\n summary[key].append(current_value)\n\n return summary","def dist_pred_dict(self, curr):\n dist = {}\n pred = {}\n for currency in self.currencies:\n dist[currency] = float('inf') # set all starting vertices to be infinite distance away\n pred[currency] = None\n\n dist[curr] = 0\n\n return dist, pred","def prime_error_rate_dic(aa_order):\n aa_error_rate_dic = {}\n for i in aa_order:\n #first element of definitions are the from mutation rate\n #and the second element is the to mutation rate\n aa_error_rate_dic[i] = [0.0, 0.0]\n return aa_error_rate_dic","def from_keyed_iterable(iterable, key, filter_func=None):\n\n generated = {}\n\n for element in iterable:\n try:\n k = getattr(element, key)\n except AttributeError:\n raise RuntimeError(\"{} does not have the keyed attribute: {}\".format(\n element, key\n ))\n\n if filter_func is None or filter_func(element):\n if k in generated:\n generated[k] += [element]\n else:\n generated[k] = [element]\n\n return generated","def auxiliary(dict_):\n dict_['AUX'] = {}\n if dict_['DIST']['coeff'] == [0.0] * len(dict_['DIST']['coeff']):\n is_deterministic = True\n else:\n is_deterministic = False\n\n for key_ in ['UNTREATED', 'TREATED', 'COST', 'DIST']:\n if key_ in ['UNTREATED', 'TREATED', 'COST']:\n dict_[key_]['all'] = dict_[key_]['coeff']\n dict_[key_]['all'] = np.array(dict_[key_]['all'])\n else:\n dict_[key_]['all'] = dict_[key_]['coeff']\n dict_[key_]['all'] = np.array(dict_[key_]['all'])\n\n # Number of covariates\n num_covars_out = len(dict_['TREATED']['all'])\n num_covars_cost = len(dict_['COST']['all'])\n\n dict_['AUX']['num_covars_out'] = num_covars_out\n dict_['AUX']['num_covars_cost'] = num_covars_cost\n\n # Number of parameters\n dict_['AUX']['num_paras'] = 2 * num_covars_out + num_covars_cost + 2 + 2\n\n # Starting values\n dict_['AUX']['init_values'] = []\n\n for key_ in ['TREATED', 'UNTREATED', 'COST', 'DIST']:\n dict_['AUX']['init_values'] += dict_[key_]['all'].tolist()\n\n for j in sorted(dict_[key_].keys()):\n if j in ['all', 'types']:\n pass\n else:\n del dict_[key_][j]\n dict_['DETERMINISTIC'] = is_deterministic\n dict_ = check_types(dict_)\n\n return dict_","def reduceby(keyfn, binop, seq, init):\n d = {}\n for item in seq:\n key = keyfn(item)\n if key not in d:\n d[key] = init\n d[key] = binop(d[key], item)\n return d","def itervalues(self):\n def make_iter(self=self):\n keys = self.iterkeys()\n while True:\n yield self[keys.next()]\n return make_iter()","def get_prices_dict(name,products,sales):\r\n return {x:(1-sales[name])*products[x] for x in products}","def dictionary_of_metrics(items):\n \n n = len(items)\n average = round(np.mean(items), 2)\n median = round(np.median(items), 2)\n variance = round((sum((items-np.mean(items))**2))/(n-1), 2)\n standard_dev = round(((sum((items-np.mean(items))**2))/(n-1))**(1/2), 2)\n minimum = round(min(items), 2)\n maximum = round(max(items), 2)\n \n return {'mean':average,'median':median,'var':variance,'std':standard_dev,'min':minimum,'max':maximum}\n pass","def get_aggregated_values(self):\n if not self._initialized:\n raise Exception(\"To readout you must first initialize, then\"\n \"process batches!\")\n else:\n ret_vals = [q.readout() for q in self.quantities]\n return dict(zip(self.quantity_names, ret_vals))","def distr(self,X):\r\n return {x:X.count(x) for x in set(X)}","def _get_lags_dict(self):\n lags_dict = {}\n for fcst_date in self.dates:\n day_of_year = self.calculate_day_of_year(fcst_date)\n for init_date in self.init_dates:\n lag = day_of_year - self.calculate_day_of_year(init_date)\n days_of_year = lags_dict.get(lag)\n if days_of_year:\n days_of_year.append(day_of_year)\n else:\n lags_dict[lag] = [day_of_year]\n \n return lags_dict","def bucket(things, key):\n ret = defaultdict(list)\n for thing in things:\n ret[key(thing)].append(thing)\n return ret","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['lambda'] = self.lambdaVar\n retDict['low'] = self.low\n return retDict","def normalize_counter(c):\n total = sum(c.values())\n return {w:float(c[w])/total for w in c}","def make_dict(keys, values):\n\n return dict(zip(keys, values))","def return_factorized_dict(ls):\r\n factos = pd.unique(pd.factorize(ls)[0])\r\n categs = pd.unique(pd.factorize(ls)[1])\r\n if -1 in factos:\r\n categs = np.insert(categs,np.where(factos==-1)[0][0],np.nan)\r\n return dict(zip(categs,factos))","def compute_increase_rate(input_data):\n rates = {}\n for comp in input_data:\n stock_prices = input_data[comp][1]\n rates[comp] = []\n for i in range(len(stock_prices)-1):\n # Add a new increase rate to the dictionary\n rates[comp].append((stock_prices[i] - stock_prices[i+1])/stock_prices[i+1])\n return rates","def __init__(self, tsa, tsastats=None):\n self.__data = {}\n self.__keys = tuple(tsa.keys())\n self.__value_keynames = tuple(tsa.value_keynames)\n for value_keyname in self.__value_keynames:\n try:\n self.__data[value_keyname] = Quantile(tsa, value_keyname, tsastats=tsastats)\n except QuantileError as exc:\n logging.exception(exc)\n logging.error(\"skipping value_key %s\", value_keyname)","def sum_by(d: D, *, keyfunc: Callable[..., Hashable], **kwds: Any) -> NumDict:\n\n value = by(d, sum, keyfunc, **kwds)\n _kwds = {\"keyfunc\": keyfunc}\n _kwds.update(kwds)\n record_call(sum_by, value, (d,), _kwds)\n\n return value","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['mu'] = self.mu\n return retDict","def __next__(self) -> dict:\n batches = {}\n terminations = 0\n for iterator in self.iterators:\n \n try:\n data, target = next(iterator)\n batches[data.location] = (data, target)\n\n except (TypeError, AttributeError) as e:\n logging.warning(f\"Dangling pointer detected! Skipping operation... Error: {e}\")\n \n except StopIteration:\n terminations += 1\n\n # Every cached iterator has been iterated through completely\n if terminations == len(self.iterators):\n raise StopIteration\n\n return batches","def aggregateSimilarityDict(collected_list):\n similarity_dict = defaultdict(list)\n for tup in collected_list:\n similarity_dict[tup[0]] += tup[1]\n for e in similarity_dict.keys():\n similarity_dict[e] = list(set(similarity_dict[e]))\n return dict(similarity_dict)","def multiplier_calculation(iterator):\n\tres = [0, 0, 0] # res[0] = mult X^0, res[1] = mult X^1, res[2] = mult X^2\n\teq_sign = False\n\tfor items in iterator:\n\t\tif items.group('eq'):\n\t\t\teq_sign = True\n\t\tif eq_sign is False:\n\t\t\tif items.group('sign') is None or items.group('sign') == '+':\n\t\t\t\tres[int(items.group('pow'))] += float(items.group('mult'))\n\t\t\telse:\n\t\t\t\tres[int(items.group('pow'))] -= float(items.group('mult'))\n\t\telse:\n\t\t\tif items.group('sign') == '+':\n\t\t\t\tres[int(items.group('pow'))] -= float(items.group('mult'))\n\t\t\telse:\n\t\t\t\tres[int(items.group('pow'))] += float(items.group('mult'))\n\treturn {'a': res[2], 'b': res[1], 'c': res[0]}","def exp(d: D) -> NumDict:\n\n return d.exp()","def construct_all_holdings(self):\n d = dict((k,v) for k,v in [(s,0.0) for s in self.symbol_list])\n d['datetime'] = self.start_date\n d['cash'] = self.initial_capital\n d['commission'] = 0.0\n d['total'] = self.initial_capital\n \n return [d]","def construct_all_holdings(self):\n d = dict((k,v) for k,v in [(s,0.0) for s in self.symbol_list])\n d['datetime'] = self.start_date\n d['cash'] = self.initial_capital\n d['commission'] = 0.0\n d['total'] = self.initial_capital\n \n return [d]","def keyby(iteratee, seq):\n iteratee = fnc.iteratee(iteratee)\n return {iteratee(value): value for value in seq}","def results(self):\n \n results = {}\n if self.descriptors is not None:\n for i in range(len(self.items)):\n results[self.items[i]] = {'I': self.ivalue(i),\n 'J': self.jvalue(i)}\n else:\n for i in range(len(self.items)):\n results[self.items[i]] = {'I': self.ivalue(i)}\n return results","def adj_dict(self):\n adj_dict = {i: [] for i in self.indices}\n for coeff in self.interactions[1:]:\n for _inds, value in coeff.items():\n for i in _inds:\n _inds_list = list(_inds)\n _inds_list.remove(i)\n adj_dict[i].append([_inds_list, value])\n return adj_dict","def relative(dict):\n retval = {}\n count = float(sum(dict.values()))\n for k, v in dict.iteritems():\n retval[k] = v / count\n return retval","def group_by(y):\n\n y_dict = {}\n for i, value in enumerate(y):\n try:\n y_dict[value]\n #Value in dictionary\n y_dict[value].append(i)\n except:\n #Value not in dictionary\n y_dict[value] = [i]\n\n return y_dict","def values(self, start: XValue[T], stop: XValue[T], step: XValueDiff[T]) -> \"SortedDict[XValue[T], float]\":\n\n step = step or (stop - start)\n if len(self.breakpoints) == 0:\n num_values = int(math.ceil((stop - start) / step))\n return SortedDict([(start + step * i, self._initial_value) for i in range(num_values)])\n\n curr_xval = start\n curr_value = self.call(start)\n next_index, next_breakpoint, next_value = self._breakpoint_info(self.breakpoints.bisect(start))\n\n sequence = SortedDict()\n while curr_xval < stop:\n sequence[curr_xval] = curr_value\n\n next_xval = min(stop, curr_xval + step)\n while next_breakpoint and next_xval >= next_breakpoint:\n assert next_index is not None # if next_breakpoint is set, next_index should also be set\n curr_value = next_value\n next_index, next_breakpoint, next_value = self._breakpoint_info(next_index + 1)\n curr_xval = next_xval\n\n return sequence","def fetch_dict(datagen, keep_prob=0.5):\n bx, by, br = next(datagen)\n while not (bx.shape[0] > 0 and bx.shape[1] > 0):\n bx, by, br = next(datagen)\n\n dec_lengths = np.full((bx.shape[0], ), bx.shape[1], dtype=np.int32)\n\n feed_dict = {\n self.xs_: bx,\n self.ys_: by,\n self.dec_inputs_length_: dec_lengths,\n self.ext_context_: br,\n self.keep_prob_: keep_prob\n }\n return feed_dict","def combiner(self, key, values):\n yield key, sum(values, ValueFormat(0, 0))","def _fit_result_from_list(a: Sequence[float]) -> Union[Dict[str, float], None]:\n if not len(a):\n return None\n return {\"amplitude\": a[0], \"center\": a[1:3], \"sigma\": a[3:5],\n \"rotation\": a[5], \"offset\": a[6] if len(a) > 6 else 0}","def nanify_dict_of_lists(dict_):\n return {k: [float('nan')]*len(v) for k, v in dict_.items()}","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['n'] = self.n\n retDict['p'] = self.p\n return retDict","def group(iterable, key=None):\n\n groups = collections.defaultdict(list)\n if key is None:\n for k, v in iterable:\n groups[k].append(v)\n else:\n for x in iterable:\n groups[key(x)].append(x)\n return groups","def groupby(iteratee, seq):\n result = {}\n iteratee = fnc.iteratee(iteratee)\n\n for item in seq:\n result.setdefault(iteratee(item), []).append(item)\n\n return result","def generate_perfomances(x):\n\n\ty=OrderedDict()\n\n\t# Cycles through both the values and the keys in the dictionary, creating a new dictionary which has within it\n\t# The names coupled with their normal distribution values\n\n\tfor xValues,names in zip(x.values(),x): y[names]=random.normalvariate(xValues[0],xValues[1])\n\treturn y","def _interpolate_single_values(A, topic):\n interp_dic = {}\n k, d = get_sorted_keys_and_data(A[topic])\n for i in range(0, len(k) - 1):\n for j in range(int(k[i] * 1000), int(k[i + 1] * 1000)):\n v = round((d[i + 1] - d[i]) / (k[i + 1] - k[i]) * (j / 1000. - k[i]) + d[i], 3)\n interp_dic[j / 1000.] = v\n return interp_dic","def _construct_all_holdings(self):\n d = dict((s, 0.0) for s in self.symbol_list)\n d['datetime'] = self.backtest_date\n d['cash'] = self.initial_capital\n d['commission'] = 0.0\n d['total'] = self.initial_capital\n d['buy_times'] = 0\n d['sell_times'] = 0\n d['total_times'] = 0\n d['hold'] = 0\n return [d]","def recalculate_ingredients(self, ingredients, factor):\n result = dict()\n for ing, val in ingredients.items():\n result[ing] = val / factor\n\n return result","def __iter__(self):\n\n # For each key in set of keys\n for key in self.keys_set:\n\n # Yield that key and associated value\n yield key, self.__getitem__(key)","def compute(self) -> Dict[str, np.ndarray]:\n return {name: self.metrics[name].compute() for name in self.metrics}","def WcCombiner(intermediates):\n\n # the use of the defaultdict data structures simplifies the summation of values (counts) of the intermediate\n # dictionaries. It only requires one statement, instead of 2, for creating a new key, value pair or\n # updating its values.\n result = defaultdict(int)\n\n # the following loop iterates over the first dictionary key and value pairs and then iterates over the next dictionary's\n # pairs. It continues until it iterates over all dictionaries that are members of the intermediates. While iterating,\n # a new dictionary is created, result, to hold all the pairs of the intermediate dictionaries, thus effectively\n # merging all of them.\n for k,v in chain(*intermediates):\n result[k] += v\n return result","def all_reduce(self):\n return {k: reduce_number(v) for k, v in self.items()}","def _sum_over_dicts(total_n_grams: Dict[int, Tensor], n_grams: Dict[int, Tensor]) ->Dict[int, Tensor]:\n for n in n_grams:\n total_n_grams[n] += n_grams[n]\n return total_n_grams","def iteritems(self):\r\n for wr, value in self.data.iteritems():\r\n key = wr()\r\n if key is not None:\r\n yield key, value","def iteritems(self):\r\n for wr, value in self.data.iteritems():\r\n key = wr()\r\n if key is not None:\r\n yield key, value","def iter_nums():\n saved = dict()\n\n def get_or_zero(x, y):\n \"\"\" Get the value at (x, y) in the cache, or return 0 \"\"\"\n coord = (x, y)\n if coord in saved:\n return saved[coord]\n else:\n return 0\n\n for coord in iter_coords():\n x, y = coord\n if coord == (0, 0):\n val = 1\n else:\n val = 0\n val += get_or_zero(x-1, y-1)\n val += get_or_zero(x, y-1)\n val += get_or_zero(x+1, y-1)\n val += get_or_zero(x-1, y)\n val += get_or_zero(x+1, y)\n val += get_or_zero(x-1, y+1)\n val += get_or_zero(x, y+1)\n val += get_or_zero(x+1, y+1)\n\n saved[coord] = val\n\n yield val","def itervalues(self):\n return DictValuesIterator(self)","def aggregate_pairs(horizon_host, pairs, start, end, resolution):\n retval = {}\n for pair in pairs:\n name = pair[\"name\"]\n if name not in retval:\n retval[name] = (0, 0, 0)\n retval[name] = sum_tuples(retval[name], aggregate_pair(horizon_host, pair, start, end, resolution))\n return retval","def get_cumulative_distribution(self):\n srt_dists = np.sort(self._distances)\n tol = 1E-3\n for i in range(1, len(srt_dists)):\n while srt_dists[i] - srt_dists[i-1] < tol:\n srt_dists[i] += tol\n return {\"x\": srt_dists-srt_dists[0], \n \"P\": np.linspace(0.0, 1.0, len(self._distances), endpoint=False)}","def evaluate(out_dict, n):\n out = dict()\n for key, entry in out_dict.items():\n out[key] = dict()\n for it_count, data in entry.items():\n total = 0.\n count = 0\n for x_list in data.values():\n total += analytic_value_VaR(x_list[-1])\n count += 1\n out[key][it_count] = total / count\n np.save('normal_out_all_cvar_%d.npy' % n, out)\n print(out)","def _calculate_medians( locations ):\n return {k: (l[0]+l[1])/2 for k, l in locations.iteritems()}","def countby(iteratee, seq):\n return dict(Counter(map(iteratee, seq)))","def make_dict(unused_s, unused_l, toks):\n result = {}\n key_value_pairs = chunks(toks, 2)\n for key_value_pair in key_value_pairs:\n result[key_value_pair[0]] = key_value_pair[1]\n return result","def stimulate(self, position_values, num_trials):\r\n \r\n result = {}\r\n for p in position_values:\r\n cumu_ret = np.zeros(num_trials)\r\n daily_ret = np.zeros(num_trials)\r\n \r\n for trial in range(self.num_trials):\r\n cumu_num = 0\r\n \r\n for i in range(int(1000/p)):\r\n random_num = np.random.rand()\r\n \r\n if (0 <= random_num <= 0.51):\r\n cumu_num = cumu_num + 2 * p\r\n elif (1 > random_num > 0.51):\r\n cumu_num = cumu_num\r\n \r\n cumu_ret[trial] = cumu_num\r\n daily_ret[trial] = cumu_ret[trial]/1000 - 1\r\n \r\n result[int(1000/p)] = daily_ret\r\n \r\n return result","def getCrowDistDict(self):\n retDict = Distribution.getCrowDistDict(self)\n retDict['scale'] = self.scale\n retDict['location'] = self.location\n return retDict"],"string":"[\n \"def add_densities(densities):\\n\\n return {spin: sum(np.array(dens[spin]) for dens in densities) \\n for spin in densities[0].keys()}\",\n \"def build_histogram(iterator, key):\\n buckets = defaultdict(int)\\n values = {}\\n\\n num_objects = 0\\n for obj in iterator:\\n num_objects += 1\\n\\n try:\\n val = obj[key]\\n except (KeyError, TypeError):\\n continue\\n\\n value_hash = hashlib.sha1()\\n value_hash.update(syaml.dump_config(sort_yaml_obj(val)).encode())\\n value_hash = value_hash.hexdigest()\\n\\n buckets[value_hash] += 1\\n values[value_hash] = val\\n\\n return [\\n (h, buckets[h], float(buckets[h]) / num_objects, values[h])\\n for h in sorted(buckets.keys(), key=lambda k: -buckets[k])\\n ]\",\n \"def _create_freq_dist(self):\\r\\n freq_dict = dict()\\r\\n\\r\\n for element in self.data:\\r\\n if element in freq_dict:\\r\\n freq_dict[element] += 1\\r\\n else:\\r\\n freq_dict[element] = 1\\r\\n\\r\\n return freq_dict\",\n \"def probability(self):\\r\\n \\r\\n my_dict = dict()\\r\\n \\r\\n for i in self.__dtmc:\\r\\n \\r\\n sum_Pij = float(sum([self.__dtmc[i][j] for j in self.__dtmc[i]]))\\r\\n \\r\\n if sum_Pij == 0:\\r\\n \\r\\n my_dict[i] = dict()\\r\\n \\r\\n elif sum_Pij > 0:\\r\\n \\r\\n if i not in my_dict:\\r\\n \\r\\n my_dict[i] = dict()\\r\\n \\r\\n for j in self.__dtmc[i]:\\r\\n \\r\\n Pij = self.__dtmc[i][j] / sum_Pij\\r\\n \\r\\n my_dict[i][j] = Pij\\r\\n \\r\\n return my_dict\",\n \"def collect_by_key(pair_iter):\\n out = {}\\n for (k, v) in pair_iter:\\n out[k] = out.get(k, [])\\n out[k].append(v)\\n return out\",\n \"def process_datapoints(datapoints):\\n point_dict = {}\\n\\n ddata = [p for p in datapoints]\\n for point in ddata:\\n point_dict[hash_datapoint(point)] = {'results': [],\\n 'time': [],\\n 'features': point['features']}\\n\\n for point in ddata:\\n point_dict[hash_datapoint(point)]['results'].append(point['result'])\\n point_dict[hash_datapoint(point)]['time'].append(point['time'])\\n\\n for e in point_dict:\\n result_array = np.array(point_dict[e]['results'])\\n point_dict[e]['n'] = len(point_dict[e]['results'])\\n point_dict[e]['mu'] = np.mean(result_array)\\n point_dict[e]['sigma'] = np.std(result_array)\\n del point_dict[e]['results']\\n\\n return point_dict\",\n \"def calcRs(distances):\\n r = {}\\n \\n for key in distances.keys():\\n summedDistances = 0\\n for subkey in distances[key].keys():\\n summedDistances += distances[key][subkey]\\n r[key] = summedDistances/(len(distances.keys())-2)\\n\\n return r\",\n \"def daily_speed_sum_reduce(key, values):\\n\\tyield \\\"%s: %s, %s\\\\n\\\" % (key, sum([int(value) for value in values]), len(values))\",\n \"def dictionary_of_metrics(items):\\n\\n 'Initialize dict'\\n d = {}\\n\\n # Add 'mean' key to the dict with the value of the mean calculate by using\\n # np.mean rounded to 2 decimal places\\n d['mean'] = round(np.mean(items), 2)\\n\\n # Add 'median' key to the dict with the value of the median calculate by\\n # using np.median rounded to 2 decimal places\\n d['median'] = round(np.median(items), 2)\\n\\n # Add 'var' key to the dict with the value of the varience calculate by\\n # using np.var rounded to 2 decimal places\\n d['var'] = round(np.var(items, ddof=1), 2)\\n\\n # Add 'std' key to the dict with the value of the standard deviation\\n # calculate by using np.std to 2 decimal places\\n d['std'] = round(np.std(items, ddof=1), 2)\\n\\n # Add 'min' key to the dict with the value of the minimum calculate by\\n # using np.min to 2 decimal places\\n d['min'] = round(np.min(items), 2)\\n\\n # Add 'max' key to the dict with the value of the maximum calculate by\\n # using np.max to 2 decimal places\\n d['max'] = round(np.max(items), 2)\\n\\n # returns dictionary, d\\n return d\",\n \"def dict(self) -> Dict[str, List[NumericType]]:\\n return {r.name: r.floats() for r in self._records}\",\n \"def compute_key_value(self) -> Dict[str, float]:\\n # @TODO: ddp hotfix, could be done better\\n if self._is_ddp:\\n for key in self.statistics:\\n value: List[np.ndarray] = all_gather(self.statistics[key])\\n value: np.ndarray = np.sum(np.vstack(value), axis=0)\\n self.statistics[key] = value\\n\\n per_class, micro, macro, weighted = self.compute()\\n metrics = self._convert_metrics_to_kv(\\n per_class=per_class, micro=micro, macro=macro, weighted=weighted\\n )\\n return metrics\",\n \"def dictionary_of_metrics(items):\\n total = 0\\n count = 0\\n for value in items:\\n total = total + value\\n count = count + 1\\n the_mean = round(total / count, 2)\\n sorted_items = sorted(items)\\n if count % 2 == 1:\\n the_median = sorted_items[int(round(count+1)/2-1)]\\n else:\\n lower_median = sorted_items[int(round(count/2-1))]\\n upper_median = sorted_items[int(round(count/2))]\\n the_median = (lower_median + upper_median) / 2\\n sum_of_sqz = 0 # Calculate Sum of squares for Varience\\n for j in items:\\n sqrz_calc = (j - the_mean)**2\\n sum_of_sqz = sum_of_sqz + sqrz_calc\\n the_varience = round(sum_of_sqz / (count - 1), 2)\\n the_standard_dev = round((the_varience)**(1/2), 2)\\n the_min = sorted_items[0]\\n the_max = sorted_items[count - 1]\\n dict = {\\n 'mean': the_mean,\\n 'median': the_median,\\n 'var': the_varience,\\n 'std': the_standard_dev,\\n 'min': the_min,\\n 'max': the_max\\n }\\n return dict\",\n \"def compute_empirical_distribution(values):\\n distribution = {}\\n\\n # -------------------------------------------------------------------------\\n # YOUR CODE HERE\\n #\\n for value in values:\\n if value not in distribution:\\n distribution[value] = 1\\n else:\\n distribution[value] += 1\\n \\n total = len(values)\\n for v in distribution.keys():\\n distribution[v] /= total\\n \\n\\n #\\n # END OF YOUR CODE\\n # -------------------------------------------------------------------------\\n\\n return distribution\",\n \"def build_intermediate_dict(self) -> Dict[str, float]:\\n intermediate = {}\\n now = datetime.now()\\n current_time = now.replace(hour=0, minute=0, second=0, microsecond=0)\\n\\n delta = timedelta(minutes=15)\\n\\n for i in range(0, 96):\\n intermediate[self.date_to_intermediate_time_str(current_time)] = 0.0\\n current_time = current_time + delta\\n\\n return intermediate\",\n \"def values_to_dict(keys: tuple, values: list) -> dict:\\n out = {}\\n for i, key in enumerate(keys):\\n out[key] = np.array([x[i] for x in values])\\n return out\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['lambda'] = self.lambdaVar\\n retDict['k'] = self.k\\n retDict['low'] = self.low\\n return retDict\",\n \"def accumulate (cls, dict, inverse=False):\\n total = 0\\n output = {}\\n keys = range(0, cls.max_key(dict) + 1)\\n if inverse:\\n keys = range(cls.max_key(dict), -1, -1) # Invert range if needed.\\n for i in keys:\\n if i in dict:\\n total += dict[i] # Accumulate frequencies.\\n output[i] = total\\n return output\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['mu'] = self.mean\\n retDict['sigma'] = self.sigma\\n retDict['low'] = self.low\\n return retDict\",\n \"def aggregator(index_keynames, value_keynames, ts_keyname, func, interval = 60 * 5):\\n data = {}\\n ts = None\\n #print ts_keyname\\n for parsts, parsdata in func():\\n #print parsdata\\n #print parsdata[\\\"log_timestamp\\\"]\\n if ts is None:\\n ts = parsts\\n key = tuple((parsdata[key] for key in index_keynames))\\n values = tuple((int(parsdata[key]) for key in value_keynames))\\n if key not in data:\\n data[key] = values\\n else:\\n data[key] = tuple((data[key][index] + int(values[index]) for index in range(len(values))))\\n if parsts > (ts + interval):\\n for keys, values in data.items():\\n yield \\\"%s\\\\t%s\\\\t%s\\\" % (ts, \\\"\\\\t\\\".join((str(index_key) for index_key in keys)), \\\"\\\\t\\\".join((str(value_key) for value_key in values)))\\n ts = None\\n data = {}\",\n \"def associate(keys, values):\\n result = {}\\n val_it = iter(values)\\n\\n for key in keys:\\n try:\\n result[key] = next(val_it)\\n except StopIteration:\\n result[key] = None\\n return result\",\n \"def calc_sim_collector(self, key, values):\\r\\n (rest1, rest2), common_ratings = key, values\\r\\n\\t #your code here\\r\\n yield (rest1, rest2), (rho, n_common)\",\n \"def update_dict(self, total_dict: dict, iter_dict: dict) -> dict:\\n for k in iter_dict:\\n if k not in total_dict:\\n total_dict[k] = iter_dict[k]\\n else:\\n total_dict[k] += iter_dict[k]\\n \\n return total_dict\",\n \"def _buildTotalsDict(self, fromdt, todt):\\r\\n pairs = [(t, t.effectForPeriod(fromdt, todt)) for t in self.transactions]\\r\\n return dict(pairs)\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['mu'] = self.mean\\n retDict['sigma'] = self.sigma\\n return retDict\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['k'] = self.alpha\\n retDict['theta'] = 1.0/self.beta\\n retDict['low'] = self.low\\n return retDict\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['alpha'] = self.alpha\\n retDict['beta'] = self.beta\\n retDict['scale'] = self.high-self.low\\n retDict['low'] = self.low\\n return retDict\",\n \"def group_by(data, key_func=identity, value_func=identity):\\n\\n def reduce(dic, ele):\\n k = key_func(ele)\\n if k in dic:\\n dic[k].append(value_func(ele))\\n else:\\n dic[k] = [value_func(ele)]\\n return dic\\n\\n return functools.reduce(reduce, data, {})\",\n \"def test_metric(self, qset: Iterator[Tuple[str, float]]) -> Dict[str, float]:\\n res = dict(mks0=0.0, mks1=0.0, mks2=0.0, sum_weights=0.0, sum_wlen=0.0, n=0)\\n hist = {k: {} for k in {\\\"mks0\\\", \\\"mks1\\\", \\\"mks2\\\", \\\"l\\\"}} # pylint: disable=C0208\\n wei = {k: {} for k in hist}\\n res[\\\"hist\\\"] = hist\\n res[\\\"histnow\\\"] = wei\\n\\n for el, _ in self.enumerate_test_metric(qset):\\n le = len(el.value)\\n w = el.weight\\n res[\\\"mks0\\\"] += w * el.mks0\\n res[\\\"mks1\\\"] += w * el.mks1\\n res[\\\"mks2\\\"] += w * el.mks2\\n res[\\\"sum_weights\\\"] += w\\n res[\\\"sum_wlen\\\"] += w * le\\n res[\\\"n\\\"] += 1\\n\\n if el.mks0 not in hist[\\\"mks0\\\"]:\\n hist[\\\"mks0\\\"][el.mks0] = w\\n wei[\\\"mks0\\\"][el.mks0] = 1\\n else:\\n hist[\\\"mks0\\\"][el.mks0] += w\\n wei[\\\"mks0\\\"][el.mks0] += 1\\n if el.mks1 not in hist[\\\"mks1\\\"]:\\n hist[\\\"mks1\\\"][el.mks1] = w\\n wei[\\\"mks1\\\"][el.mks1] = 1\\n else:\\n hist[\\\"mks1\\\"][el.mks1] += w\\n wei[\\\"mks1\\\"][el.mks1] += 1\\n if el.mks2 not in hist[\\\"mks2\\\"]:\\n hist[\\\"mks2\\\"][el.mks2] = w\\n wei[\\\"mks2\\\"][el.mks2] = 1\\n else:\\n hist[\\\"mks2\\\"][el.mks2] += w\\n wei[\\\"mks2\\\"][el.mks2] += 1\\n if le not in hist[\\\"l\\\"]:\\n hist[\\\"l\\\"][le] = w\\n wei[\\\"l\\\"][le] = 1\\n else:\\n hist[\\\"l\\\"][le] += w\\n wei[\\\"l\\\"][le] += 1\\n return res\",\n \"def reduceWith(aggregation_fn, key, values ):\\n yield (key, aggregation_fn(values))\",\n \"def gen_dict():\\n lines = [line for line in csv.reader(open(__ppath__ + \\\"/data/occupations.csv\\\"))] # uses a csv.reader to parse the file, converts the generic iterable to a list\\n lines = [(line[0],float(line[1])) for line in lines[1:-2]]# removes the column names and \\\"Total\\\" row, re-expresses as a list of tuples to enable dictionary conversion\\n lines.append((\\\"Unemployed\\\",0.2)) # accounts for missing 0.2% of jobs\\n return dict(lines) # converts to dictionary\",\n \"def extract_data(self):\\n values = {}\\n for injkey in self.data_sets.keys():\\n values[injkey] = {}\\n alldata = self.data_sets[injkey]\\n paramkeys = alldata['params'].keys()\\n for datakey in alldata.keys():\\n if not datakey == 'params':\\n values[injkey][datakey] = {}\\n values[injkey][datakey]['metric_val'] = {}\\n values[injkey][datakey]['metric_val']['vals'] = []\\n for paramkey in paramkeys:\\n values[injkey][datakey][paramkey] = {}\\n values[injkey][datakey][paramkey]['vals'] = []\\n trials = alldata[datakey]\\n for trial_num in trials.keys():\\n trial = trials[trial_num]\\n values[injkey][datakey]['metric_val']['vals'] \\\\\\n .append(trial['metric_val'])\\n values[injkey][datakey]['metric_val']['type'] \\\\\\n = trial['metric']\\n values[injkey][datakey]['metric_val']['units'] \\\\\\n = 'dimensionless'\\n param_vals = trial['params']\\n for param_name in param_vals.keys():\\n val, units = self.parse_pint_string(\\n pint_string=param_vals[param_name]\\n )\\n values[injkey][datakey][param_name]['vals'] \\\\\\n .append(float(val))\\n values[injkey][datakey][param_name]['units'] \\\\\\n = units\\n self.values = values\",\n \"def initDictionary(bands):\\r\\n for x in bands:\\r\\n d[\\\"{}\\\".format(x)] = {ProdCost: [], AlbumSales: []}\",\n \"def convertSumsToMap(arr, values):\\n num_map = {}\\n for item in values:\\n num_map[item] = []\\n\\n for i in range(len(arr)):\\n num_map[i+1] = setFromValues(arr[i])\\n\\n return num_map\",\n \"def multDic(dic, x):\\n pass\",\n \"def dictionary_of_metrics(items):\\n \\n np_list = np.array(items) #create an array of list to use numpy functions on list\\n metric_dict = {'mean': np.mean(np_list).round(2),\\n 'median': np.median(np_list).round(2),\\n 'var': np.var(np_list, ddof=1).round(2),\\n 'std': np.std(np_list, ddof=1).round(2),\\n 'min': np.min(np_list).round(2),\\n 'max': np.max(np_list).round(2),} #create a dictionary that calculates the five metrics\\n \\n return metric_dict #return result as a dictionary\",\n \"def histogramintegrals(self):\\n return {}\",\n \"def build_coeff_dict(l):\\n coeff_dict = {}\\n for triplet in l:\\n coeff_dict[triplet[0]] = triplet[2]\\n return coeff_dict\",\n \"def __iter__(self):\\n key = list(self.keys())[0]\\n length = len(self[key])\\n for i in range(length):\\n res = {}\\n for key, feature in self.items():\\n res[key] = feature.data[feature.name][i]\\n yield res\",\n \"def __iter__(self):\\n prefix = len(META_NS) + 2\\n for key, value in self.stats.items():\\n yield (key[prefix:-6], int(value))\",\n \"def summarize_data(data, summary_keys):\\n summary = {}\\n latest_iteration_number = len(data.keys())\\n current_value = None\\n\\n for key in summary_keys:\\n summary[key] = []\\n # Compute per-iteration average of the given key.\\n for i in range(latest_iteration_number):\\n iter_key = '{}{}'.format(ITERATION_PREFIX, i)\\n # We allow reporting the same value multiple times when data is missing.\\n # If there is no data for this iteration, use the previous'.\\n if iter_key in data:\\n current_value = np.mean(data[iter_key][key])\\n summary[key].append(current_value)\\n\\n return summary\",\n \"def dist_pred_dict(self, curr):\\n dist = {}\\n pred = {}\\n for currency in self.currencies:\\n dist[currency] = float('inf') # set all starting vertices to be infinite distance away\\n pred[currency] = None\\n\\n dist[curr] = 0\\n\\n return dist, pred\",\n \"def prime_error_rate_dic(aa_order):\\n aa_error_rate_dic = {}\\n for i in aa_order:\\n #first element of definitions are the from mutation rate\\n #and the second element is the to mutation rate\\n aa_error_rate_dic[i] = [0.0, 0.0]\\n return aa_error_rate_dic\",\n \"def from_keyed_iterable(iterable, key, filter_func=None):\\n\\n generated = {}\\n\\n for element in iterable:\\n try:\\n k = getattr(element, key)\\n except AttributeError:\\n raise RuntimeError(\\\"{} does not have the keyed attribute: {}\\\".format(\\n element, key\\n ))\\n\\n if filter_func is None or filter_func(element):\\n if k in generated:\\n generated[k] += [element]\\n else:\\n generated[k] = [element]\\n\\n return generated\",\n \"def auxiliary(dict_):\\n dict_['AUX'] = {}\\n if dict_['DIST']['coeff'] == [0.0] * len(dict_['DIST']['coeff']):\\n is_deterministic = True\\n else:\\n is_deterministic = False\\n\\n for key_ in ['UNTREATED', 'TREATED', 'COST', 'DIST']:\\n if key_ in ['UNTREATED', 'TREATED', 'COST']:\\n dict_[key_]['all'] = dict_[key_]['coeff']\\n dict_[key_]['all'] = np.array(dict_[key_]['all'])\\n else:\\n dict_[key_]['all'] = dict_[key_]['coeff']\\n dict_[key_]['all'] = np.array(dict_[key_]['all'])\\n\\n # Number of covariates\\n num_covars_out = len(dict_['TREATED']['all'])\\n num_covars_cost = len(dict_['COST']['all'])\\n\\n dict_['AUX']['num_covars_out'] = num_covars_out\\n dict_['AUX']['num_covars_cost'] = num_covars_cost\\n\\n # Number of parameters\\n dict_['AUX']['num_paras'] = 2 * num_covars_out + num_covars_cost + 2 + 2\\n\\n # Starting values\\n dict_['AUX']['init_values'] = []\\n\\n for key_ in ['TREATED', 'UNTREATED', 'COST', 'DIST']:\\n dict_['AUX']['init_values'] += dict_[key_]['all'].tolist()\\n\\n for j in sorted(dict_[key_].keys()):\\n if j in ['all', 'types']:\\n pass\\n else:\\n del dict_[key_][j]\\n dict_['DETERMINISTIC'] = is_deterministic\\n dict_ = check_types(dict_)\\n\\n return dict_\",\n \"def reduceby(keyfn, binop, seq, init):\\n d = {}\\n for item in seq:\\n key = keyfn(item)\\n if key not in d:\\n d[key] = init\\n d[key] = binop(d[key], item)\\n return d\",\n \"def itervalues(self):\\n def make_iter(self=self):\\n keys = self.iterkeys()\\n while True:\\n yield self[keys.next()]\\n return make_iter()\",\n \"def get_prices_dict(name,products,sales):\\r\\n return {x:(1-sales[name])*products[x] for x in products}\",\n \"def dictionary_of_metrics(items):\\n \\n n = len(items)\\n average = round(np.mean(items), 2)\\n median = round(np.median(items), 2)\\n variance = round((sum((items-np.mean(items))**2))/(n-1), 2)\\n standard_dev = round(((sum((items-np.mean(items))**2))/(n-1))**(1/2), 2)\\n minimum = round(min(items), 2)\\n maximum = round(max(items), 2)\\n \\n return {'mean':average,'median':median,'var':variance,'std':standard_dev,'min':minimum,'max':maximum}\\n pass\",\n \"def get_aggregated_values(self):\\n if not self._initialized:\\n raise Exception(\\\"To readout you must first initialize, then\\\"\\n \\\"process batches!\\\")\\n else:\\n ret_vals = [q.readout() for q in self.quantities]\\n return dict(zip(self.quantity_names, ret_vals))\",\n \"def distr(self,X):\\r\\n return {x:X.count(x) for x in set(X)}\",\n \"def _get_lags_dict(self):\\n lags_dict = {}\\n for fcst_date in self.dates:\\n day_of_year = self.calculate_day_of_year(fcst_date)\\n for init_date in self.init_dates:\\n lag = day_of_year - self.calculate_day_of_year(init_date)\\n days_of_year = lags_dict.get(lag)\\n if days_of_year:\\n days_of_year.append(day_of_year)\\n else:\\n lags_dict[lag] = [day_of_year]\\n \\n return lags_dict\",\n \"def bucket(things, key):\\n ret = defaultdict(list)\\n for thing in things:\\n ret[key(thing)].append(thing)\\n return ret\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['lambda'] = self.lambdaVar\\n retDict['low'] = self.low\\n return retDict\",\n \"def normalize_counter(c):\\n total = sum(c.values())\\n return {w:float(c[w])/total for w in c}\",\n \"def make_dict(keys, values):\\n\\n return dict(zip(keys, values))\",\n \"def return_factorized_dict(ls):\\r\\n factos = pd.unique(pd.factorize(ls)[0])\\r\\n categs = pd.unique(pd.factorize(ls)[1])\\r\\n if -1 in factos:\\r\\n categs = np.insert(categs,np.where(factos==-1)[0][0],np.nan)\\r\\n return dict(zip(categs,factos))\",\n \"def compute_increase_rate(input_data):\\n rates = {}\\n for comp in input_data:\\n stock_prices = input_data[comp][1]\\n rates[comp] = []\\n for i in range(len(stock_prices)-1):\\n # Add a new increase rate to the dictionary\\n rates[comp].append((stock_prices[i] - stock_prices[i+1])/stock_prices[i+1])\\n return rates\",\n \"def __init__(self, tsa, tsastats=None):\\n self.__data = {}\\n self.__keys = tuple(tsa.keys())\\n self.__value_keynames = tuple(tsa.value_keynames)\\n for value_keyname in self.__value_keynames:\\n try:\\n self.__data[value_keyname] = Quantile(tsa, value_keyname, tsastats=tsastats)\\n except QuantileError as exc:\\n logging.exception(exc)\\n logging.error(\\\"skipping value_key %s\\\", value_keyname)\",\n \"def sum_by(d: D, *, keyfunc: Callable[..., Hashable], **kwds: Any) -> NumDict:\\n\\n value = by(d, sum, keyfunc, **kwds)\\n _kwds = {\\\"keyfunc\\\": keyfunc}\\n _kwds.update(kwds)\\n record_call(sum_by, value, (d,), _kwds)\\n\\n return value\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['mu'] = self.mu\\n return retDict\",\n \"def __next__(self) -> dict:\\n batches = {}\\n terminations = 0\\n for iterator in self.iterators:\\n \\n try:\\n data, target = next(iterator)\\n batches[data.location] = (data, target)\\n\\n except (TypeError, AttributeError) as e:\\n logging.warning(f\\\"Dangling pointer detected! Skipping operation... Error: {e}\\\")\\n \\n except StopIteration:\\n terminations += 1\\n\\n # Every cached iterator has been iterated through completely\\n if terminations == len(self.iterators):\\n raise StopIteration\\n\\n return batches\",\n \"def aggregateSimilarityDict(collected_list):\\n similarity_dict = defaultdict(list)\\n for tup in collected_list:\\n similarity_dict[tup[0]] += tup[1]\\n for e in similarity_dict.keys():\\n similarity_dict[e] = list(set(similarity_dict[e]))\\n return dict(similarity_dict)\",\n \"def multiplier_calculation(iterator):\\n\\tres = [0, 0, 0] # res[0] = mult X^0, res[1] = mult X^1, res[2] = mult X^2\\n\\teq_sign = False\\n\\tfor items in iterator:\\n\\t\\tif items.group('eq'):\\n\\t\\t\\teq_sign = True\\n\\t\\tif eq_sign is False:\\n\\t\\t\\tif items.group('sign') is None or items.group('sign') == '+':\\n\\t\\t\\t\\tres[int(items.group('pow'))] += float(items.group('mult'))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tres[int(items.group('pow'))] -= float(items.group('mult'))\\n\\t\\telse:\\n\\t\\t\\tif items.group('sign') == '+':\\n\\t\\t\\t\\tres[int(items.group('pow'))] -= float(items.group('mult'))\\n\\t\\t\\telse:\\n\\t\\t\\t\\tres[int(items.group('pow'))] += float(items.group('mult'))\\n\\treturn {'a': res[2], 'b': res[1], 'c': res[0]}\",\n \"def exp(d: D) -> NumDict:\\n\\n return d.exp()\",\n \"def construct_all_holdings(self):\\n d = dict((k,v) for k,v in [(s,0.0) for s in self.symbol_list])\\n d['datetime'] = self.start_date\\n d['cash'] = self.initial_capital\\n d['commission'] = 0.0\\n d['total'] = self.initial_capital\\n \\n return [d]\",\n \"def construct_all_holdings(self):\\n d = dict((k,v) for k,v in [(s,0.0) for s in self.symbol_list])\\n d['datetime'] = self.start_date\\n d['cash'] = self.initial_capital\\n d['commission'] = 0.0\\n d['total'] = self.initial_capital\\n \\n return [d]\",\n \"def keyby(iteratee, seq):\\n iteratee = fnc.iteratee(iteratee)\\n return {iteratee(value): value for value in seq}\",\n \"def results(self):\\n \\n results = {}\\n if self.descriptors is not None:\\n for i in range(len(self.items)):\\n results[self.items[i]] = {'I': self.ivalue(i),\\n 'J': self.jvalue(i)}\\n else:\\n for i in range(len(self.items)):\\n results[self.items[i]] = {'I': self.ivalue(i)}\\n return results\",\n \"def adj_dict(self):\\n adj_dict = {i: [] for i in self.indices}\\n for coeff in self.interactions[1:]:\\n for _inds, value in coeff.items():\\n for i in _inds:\\n _inds_list = list(_inds)\\n _inds_list.remove(i)\\n adj_dict[i].append([_inds_list, value])\\n return adj_dict\",\n \"def relative(dict):\\n retval = {}\\n count = float(sum(dict.values()))\\n for k, v in dict.iteritems():\\n retval[k] = v / count\\n return retval\",\n \"def group_by(y):\\n\\n y_dict = {}\\n for i, value in enumerate(y):\\n try:\\n y_dict[value]\\n #Value in dictionary\\n y_dict[value].append(i)\\n except:\\n #Value not in dictionary\\n y_dict[value] = [i]\\n\\n return y_dict\",\n \"def values(self, start: XValue[T], stop: XValue[T], step: XValueDiff[T]) -> \\\"SortedDict[XValue[T], float]\\\":\\n\\n step = step or (stop - start)\\n if len(self.breakpoints) == 0:\\n num_values = int(math.ceil((stop - start) / step))\\n return SortedDict([(start + step * i, self._initial_value) for i in range(num_values)])\\n\\n curr_xval = start\\n curr_value = self.call(start)\\n next_index, next_breakpoint, next_value = self._breakpoint_info(self.breakpoints.bisect(start))\\n\\n sequence = SortedDict()\\n while curr_xval < stop:\\n sequence[curr_xval] = curr_value\\n\\n next_xval = min(stop, curr_xval + step)\\n while next_breakpoint and next_xval >= next_breakpoint:\\n assert next_index is not None # if next_breakpoint is set, next_index should also be set\\n curr_value = next_value\\n next_index, next_breakpoint, next_value = self._breakpoint_info(next_index + 1)\\n curr_xval = next_xval\\n\\n return sequence\",\n \"def fetch_dict(datagen, keep_prob=0.5):\\n bx, by, br = next(datagen)\\n while not (bx.shape[0] > 0 and bx.shape[1] > 0):\\n bx, by, br = next(datagen)\\n\\n dec_lengths = np.full((bx.shape[0], ), bx.shape[1], dtype=np.int32)\\n\\n feed_dict = {\\n self.xs_: bx,\\n self.ys_: by,\\n self.dec_inputs_length_: dec_lengths,\\n self.ext_context_: br,\\n self.keep_prob_: keep_prob\\n }\\n return feed_dict\",\n \"def combiner(self, key, values):\\n yield key, sum(values, ValueFormat(0, 0))\",\n \"def _fit_result_from_list(a: Sequence[float]) -> Union[Dict[str, float], None]:\\n if not len(a):\\n return None\\n return {\\\"amplitude\\\": a[0], \\\"center\\\": a[1:3], \\\"sigma\\\": a[3:5],\\n \\\"rotation\\\": a[5], \\\"offset\\\": a[6] if len(a) > 6 else 0}\",\n \"def nanify_dict_of_lists(dict_):\\n return {k: [float('nan')]*len(v) for k, v in dict_.items()}\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['n'] = self.n\\n retDict['p'] = self.p\\n return retDict\",\n \"def group(iterable, key=None):\\n\\n groups = collections.defaultdict(list)\\n if key is None:\\n for k, v in iterable:\\n groups[k].append(v)\\n else:\\n for x in iterable:\\n groups[key(x)].append(x)\\n return groups\",\n \"def groupby(iteratee, seq):\\n result = {}\\n iteratee = fnc.iteratee(iteratee)\\n\\n for item in seq:\\n result.setdefault(iteratee(item), []).append(item)\\n\\n return result\",\n \"def generate_perfomances(x):\\n\\n\\ty=OrderedDict()\\n\\n\\t# Cycles through both the values and the keys in the dictionary, creating a new dictionary which has within it\\n\\t# The names coupled with their normal distribution values\\n\\n\\tfor xValues,names in zip(x.values(),x): y[names]=random.normalvariate(xValues[0],xValues[1])\\n\\treturn y\",\n \"def _interpolate_single_values(A, topic):\\n interp_dic = {}\\n k, d = get_sorted_keys_and_data(A[topic])\\n for i in range(0, len(k) - 1):\\n for j in range(int(k[i] * 1000), int(k[i + 1] * 1000)):\\n v = round((d[i + 1] - d[i]) / (k[i + 1] - k[i]) * (j / 1000. - k[i]) + d[i], 3)\\n interp_dic[j / 1000.] = v\\n return interp_dic\",\n \"def _construct_all_holdings(self):\\n d = dict((s, 0.0) for s in self.symbol_list)\\n d['datetime'] = self.backtest_date\\n d['cash'] = self.initial_capital\\n d['commission'] = 0.0\\n d['total'] = self.initial_capital\\n d['buy_times'] = 0\\n d['sell_times'] = 0\\n d['total_times'] = 0\\n d['hold'] = 0\\n return [d]\",\n \"def recalculate_ingredients(self, ingredients, factor):\\n result = dict()\\n for ing, val in ingredients.items():\\n result[ing] = val / factor\\n\\n return result\",\n \"def __iter__(self):\\n\\n # For each key in set of keys\\n for key in self.keys_set:\\n\\n # Yield that key and associated value\\n yield key, self.__getitem__(key)\",\n \"def compute(self) -> Dict[str, np.ndarray]:\\n return {name: self.metrics[name].compute() for name in self.metrics}\",\n \"def WcCombiner(intermediates):\\n\\n # the use of the defaultdict data structures simplifies the summation of values (counts) of the intermediate\\n # dictionaries. It only requires one statement, instead of 2, for creating a new key, value pair or\\n # updating its values.\\n result = defaultdict(int)\\n\\n # the following loop iterates over the first dictionary key and value pairs and then iterates over the next dictionary's\\n # pairs. It continues until it iterates over all dictionaries that are members of the intermediates. While iterating,\\n # a new dictionary is created, result, to hold all the pairs of the intermediate dictionaries, thus effectively\\n # merging all of them.\\n for k,v in chain(*intermediates):\\n result[k] += v\\n return result\",\n \"def all_reduce(self):\\n return {k: reduce_number(v) for k, v in self.items()}\",\n \"def _sum_over_dicts(total_n_grams: Dict[int, Tensor], n_grams: Dict[int, Tensor]) ->Dict[int, Tensor]:\\n for n in n_grams:\\n total_n_grams[n] += n_grams[n]\\n return total_n_grams\",\n \"def iteritems(self):\\r\\n for wr, value in self.data.iteritems():\\r\\n key = wr()\\r\\n if key is not None:\\r\\n yield key, value\",\n \"def iteritems(self):\\r\\n for wr, value in self.data.iteritems():\\r\\n key = wr()\\r\\n if key is not None:\\r\\n yield key, value\",\n \"def iter_nums():\\n saved = dict()\\n\\n def get_or_zero(x, y):\\n \\\"\\\"\\\" Get the value at (x, y) in the cache, or return 0 \\\"\\\"\\\"\\n coord = (x, y)\\n if coord in saved:\\n return saved[coord]\\n else:\\n return 0\\n\\n for coord in iter_coords():\\n x, y = coord\\n if coord == (0, 0):\\n val = 1\\n else:\\n val = 0\\n val += get_or_zero(x-1, y-1)\\n val += get_or_zero(x, y-1)\\n val += get_or_zero(x+1, y-1)\\n val += get_or_zero(x-1, y)\\n val += get_or_zero(x+1, y)\\n val += get_or_zero(x-1, y+1)\\n val += get_or_zero(x, y+1)\\n val += get_or_zero(x+1, y+1)\\n\\n saved[coord] = val\\n\\n yield val\",\n \"def itervalues(self):\\n return DictValuesIterator(self)\",\n \"def aggregate_pairs(horizon_host, pairs, start, end, resolution):\\n retval = {}\\n for pair in pairs:\\n name = pair[\\\"name\\\"]\\n if name not in retval:\\n retval[name] = (0, 0, 0)\\n retval[name] = sum_tuples(retval[name], aggregate_pair(horizon_host, pair, start, end, resolution))\\n return retval\",\n \"def get_cumulative_distribution(self):\\n srt_dists = np.sort(self._distances)\\n tol = 1E-3\\n for i in range(1, len(srt_dists)):\\n while srt_dists[i] - srt_dists[i-1] < tol:\\n srt_dists[i] += tol\\n return {\\\"x\\\": srt_dists-srt_dists[0], \\n \\\"P\\\": np.linspace(0.0, 1.0, len(self._distances), endpoint=False)}\",\n \"def evaluate(out_dict, n):\\n out = dict()\\n for key, entry in out_dict.items():\\n out[key] = dict()\\n for it_count, data in entry.items():\\n total = 0.\\n count = 0\\n for x_list in data.values():\\n total += analytic_value_VaR(x_list[-1])\\n count += 1\\n out[key][it_count] = total / count\\n np.save('normal_out_all_cvar_%d.npy' % n, out)\\n print(out)\",\n \"def _calculate_medians( locations ):\\n return {k: (l[0]+l[1])/2 for k, l in locations.iteritems()}\",\n \"def countby(iteratee, seq):\\n return dict(Counter(map(iteratee, seq)))\",\n \"def make_dict(unused_s, unused_l, toks):\\n result = {}\\n key_value_pairs = chunks(toks, 2)\\n for key_value_pair in key_value_pairs:\\n result[key_value_pair[0]] = key_value_pair[1]\\n return result\",\n \"def stimulate(self, position_values, num_trials):\\r\\n \\r\\n result = {}\\r\\n for p in position_values:\\r\\n cumu_ret = np.zeros(num_trials)\\r\\n daily_ret = np.zeros(num_trials)\\r\\n \\r\\n for trial in range(self.num_trials):\\r\\n cumu_num = 0\\r\\n \\r\\n for i in range(int(1000/p)):\\r\\n random_num = np.random.rand()\\r\\n \\r\\n if (0 <= random_num <= 0.51):\\r\\n cumu_num = cumu_num + 2 * p\\r\\n elif (1 > random_num > 0.51):\\r\\n cumu_num = cumu_num\\r\\n \\r\\n cumu_ret[trial] = cumu_num\\r\\n daily_ret[trial] = cumu_ret[trial]/1000 - 1\\r\\n \\r\\n result[int(1000/p)] = daily_ret\\r\\n \\r\\n return result\",\n \"def getCrowDistDict(self):\\n retDict = Distribution.getCrowDistDict(self)\\n retDict['scale'] = self.scale\\n retDict['location'] = self.location\\n return retDict\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6195448","0.5842633","0.5762505","0.5756769","0.5659886","0.5645777","0.5627008","0.5534746","0.5509884","0.55032265","0.54376537","0.54350764","0.54216063","0.5409323","0.540671","0.5402735","0.53859186","0.53531986","0.53487366","0.5334113","0.5327092","0.5318451","0.53141636","0.52982175","0.5296931","0.5287551","0.526345","0.52515876","0.52324295","0.5223859","0.5220057","0.521813","0.52159894","0.5199641","0.51955944","0.5144142","0.5142555","0.5139382","0.5138333","0.51354355","0.5133478","0.51316285","0.5120413","0.51203775","0.5115305","0.5107591","0.5103481","0.5102157","0.5099562","0.5098279","0.5098216","0.5092161","0.50920737","0.50816643","0.50789136","0.5062653","0.5057003","0.50512767","0.50497526","0.5043093","0.5037211","0.5035625","0.50322795","0.50308067","0.5021384","0.5021384","0.5017462","0.5005987","0.49984327","0.49932006","0.49908444","0.49897102","0.49826825","0.49804947","0.49793705","0.49789006","0.4977706","0.49718","0.49680412","0.4962317","0.4956014","0.4945189","0.4941735","0.49334547","0.4933444","0.49318954","0.4924844","0.49234772","0.491802","0.491802","0.49177614","0.4912099","0.49111253","0.49049306","0.49005538","0.48989636","0.48977298","0.48947892","0.4893446","0.48884767"],"string":"[\n \"0.6195448\",\n \"0.5842633\",\n \"0.5762505\",\n \"0.5756769\",\n \"0.5659886\",\n \"0.5645777\",\n \"0.5627008\",\n \"0.5534746\",\n \"0.5509884\",\n \"0.55032265\",\n \"0.54376537\",\n \"0.54350764\",\n \"0.54216063\",\n \"0.5409323\",\n \"0.540671\",\n \"0.5402735\",\n \"0.53859186\",\n \"0.53531986\",\n \"0.53487366\",\n \"0.5334113\",\n \"0.5327092\",\n \"0.5318451\",\n \"0.53141636\",\n \"0.52982175\",\n \"0.5296931\",\n \"0.5287551\",\n \"0.526345\",\n \"0.52515876\",\n \"0.52324295\",\n \"0.5223859\",\n \"0.5220057\",\n \"0.521813\",\n \"0.52159894\",\n \"0.5199641\",\n \"0.51955944\",\n \"0.5144142\",\n \"0.5142555\",\n \"0.5139382\",\n \"0.5138333\",\n \"0.51354355\",\n \"0.5133478\",\n \"0.51316285\",\n \"0.5120413\",\n \"0.51203775\",\n \"0.5115305\",\n \"0.5107591\",\n \"0.5103481\",\n \"0.5102157\",\n \"0.5099562\",\n \"0.5098279\",\n \"0.5098216\",\n \"0.5092161\",\n \"0.50920737\",\n \"0.50816643\",\n \"0.50789136\",\n \"0.5062653\",\n \"0.5057003\",\n \"0.50512767\",\n \"0.50497526\",\n \"0.5043093\",\n \"0.5037211\",\n \"0.5035625\",\n \"0.50322795\",\n \"0.50308067\",\n \"0.5021384\",\n \"0.5021384\",\n \"0.5017462\",\n \"0.5005987\",\n \"0.49984327\",\n \"0.49932006\",\n \"0.49908444\",\n \"0.49897102\",\n \"0.49826825\",\n \"0.49804947\",\n \"0.49793705\",\n \"0.49789006\",\n \"0.4977706\",\n \"0.49718\",\n \"0.49680412\",\n \"0.4962317\",\n \"0.4956014\",\n \"0.4945189\",\n \"0.4941735\",\n \"0.49334547\",\n \"0.4933444\",\n \"0.49318954\",\n \"0.4924844\",\n \"0.49234772\",\n \"0.491802\",\n \"0.491802\",\n \"0.49177614\",\n \"0.4912099\",\n \"0.49111253\",\n \"0.49049306\",\n \"0.49005538\",\n \"0.48989636\",\n \"0.48977298\",\n \"0.48947892\",\n \"0.4893446\",\n \"0.48884767\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.61645067"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20157,"cells":{"query":{"kind":"string","value":"Returns a histogram of the different types of relations present in a graph."},"document":{"kind":"string","value":"def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )","def relationship_types(self):\n return frozenset(self._relationships_by_type.keys())","def get_all_relations(graph, u, v):\n return {\n data[RELATION]\n for data in graph.edge[u][v].values()\n }","def bins(G):\n bins = {}\n for i in range(0, len(G.nodes(\"binary\")[0])+1):\n bins[i] = []\n\n for node in range(len(list(G.nodes()))):\n node_attr = G.node[node]\n # Calculate the level of each node\n level = node_attr[\"binary\"].count(\"1\")\n bins[level].append(node)\n\n return bins","def count_relation_doc(document):\n count = {}\n for line in document[1:]:\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\n for relation in relation_types:\n if relation in count:\n count[relation] += 1\n else:\n count[relation] = 1\n return count","def hog_histograms(*args, **kwargs): # real signature unknown\n pass","def subtype_counts(node_set, G, log=False):\n subtypes = Counter()\n for n in node_set:\n subtype = G.node[n]['subtype']\n subtypes[subtype] += 1\n\n if log:\n for k, v in subtypes.items():\n subtypes[k] = np.log10(v)\n \n return subtypes","def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))","def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\n -> typ.Dict[str, int]:\n hist = collections.Counter()\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\n return hist","def histogram_edges(edges: typ.List[typ.Tuple[int, int, int]], granularity: int=None) -> typ.List[int]:\n if len(edges) == 0:\n return list()\n if granularity is None:\n granularity = vtna.data_import.infer_update_delta(edges)\n histogram = [len(ls) for ls in vtna.data_import.group_edges_by_granularity(edges, granularity)]\n return histogram","def PlotDirectedEdgeHistogram(self, g, edgeAttribute=\"weight\", useLogP1Space=True):\n\t\tseries = []\n\t\tfor e in g.es:\n\t\t\tsrc = g.vs[e.source][\"name\"]\n\t\t\tdest = g.vs[e.target][\"name\"]\n\t\t\tif useLogP1Space:\n\t\t\t\tedgeValue = np.log(e[edgeAttribute])+1 #add one, simply for plotting\n\t\t\telse:\n\t\t\t\tedgeValue = e[edgeAttribute]\n\t\t\tpair = (src+\"--\"+dest, edgeValue)\n\t\t\tseries.append(pair)\n\t\t\n\t\tprint(str(series))\n\t\tdf = pd.Series([pair[1] for pair in series], index=[pair[0] for pair in series])\n\t\tprint(str(df))\n\t\tprint(\"Plotting...\")\n\t\tdf.sort_values().plot(kind='bar',title=\"Log-Space Host-Host Flow Frequency\")\n\t\t#hist.plot()\n\t\tplt.tight_layout()\n\t\tplt.show()\n\t\tplt.clf()\n\t\t\n\t\t#plot outgoing flow distributions, only for vertices with more than one outgoing edge\n\t\tfor v in g.vs:\n\t\t\tedges = g.es.select(_source=v.index)\n\t\t\tif len(edges) > 1:\n\t\t\t\tprint(str(len(edges)))\n\t\t\t\tneighborFrequencies = [(g.vs[e.target][\"name\"], e[\"weight\"]) for e in edges]\n\t\t\t\tprint(\"NEIGHBORS: \"+str(neighborFrequencies))\n\t\t\t\tseries = pd.Series([pair[1] for pair in neighborFrequencies], index=[pair[0] for pair in neighborFrequencies])\n\t\t\t\tseries.sort_values().plot(kind='bar',title=v[\"name\"]+\" Neighbor Flow Frequency\")\n\t\t\t\tplt.tight_layout()\n\t\t\t\tplt.show()\n\t\t\t\tplt.clf()","def relations(self):\n return set(self.triples()[\"relation\"])","def degree_histogram_directed(G, in_degree=False, out_degree=False):\n nodes = G.nodes()\n if in_degree:\n in_degree = dict(G.in_degree())\n degseq=[in_degree.get(k,0) for k in nodes]\n elif out_degree:\n out_degree = dict(G.out_degree())\n degseq=[out_degree.get(k,0) for k in nodes]\n else:\n degseq=[v for k, v in G.degree()]\n dmax=max(degseq)+1\n freq= [ 0 for d in range(dmax) ]\n for d in degseq:\n freq[d] += 1\n return freq","def GetInOutRelationsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.InputRelations][rel] = inRelations\n return res","def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses","def test_make_histograms(self):\r\n raw_lengths = [90, 100, 110, 110, 130, 135]\r\n pre_lengths = [100, 110, 105, 130, 135]\r\n post_lengths = [130, 135]\r\n raw_hist, pre_hist, post_hist, bin_edges = \\\r\n make_histograms(raw_lengths, pre_lengths, post_lengths)\r\n assert_almost_equal(pre_hist, array([0, 2, 1, 0, 2]))\r\n assert_almost_equal(post_hist, array([0, 0, 0, 0, 2]))\r\n assert_almost_equal(bin_edges, array([90, 100, 110, 120, 130, 140]))","def hist_of_numeric(X):\n figsize(10,3)\n for col in get_numeric(X):\n print(col)\n X[col].hist(bins=50)\n show()","def __init__(self, network):\n self.network = network\n self.histogram = [0] * (network.maxDegree() + 1)\n\n for key, node in network.nodes.items():\n self.histogram[node.degree()] += 1\n\n #print(\"Debug: histogram list \", self.histogram)\n\n # Other option:\n # Dict containing {id:degree}\n # self.degrees = {}\n # for node in network.nodes.iteritems():\n # self.degrees[node.identifier] = node.degree()\n # for i in range(0, network.maxDegree() + 1:\n # self.histogram[i] = self.degrees.values().count(i)","def initialize_graph(compound_relations, relation_types):\n graph = nx.DiGraph()\n for compound, targets in compound_relations.items():\n for target, relation in targets.items():\n if relation in relation_types:\n graph.add_edge(compound, target)\n return graph","def GetValRelations(self, G, node):\n res = {gc.InputRelations: [], gc.OutgoingRelations : []}\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.val in edge[2]]\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.val in edge[2]]\n res[gc.OutgoingRelations] = outEdges\n res[gc.InputRelations] = inEdges\n\n return res","def Test_Histogram(Graph_MD):\n \n Edges = NX.edges(Graph_MD)\n KnotenNamen = NX.nodes(Graph_MD)\n \n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\n NumKnotenListe = len(KnotenNamenListe)\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\n \n count = 0\n for Knoten in KnotenLeitung:\n KnotenLeitung[count] = 0\n count = count + 1\n \n \n for ii in list(range(NumKnotenListe)):\n KnotenName = KnotenNamenListe[ii]\n for edge in Edges:\n posS = edge[0] == KnotenName\n posE = edge[1] == KnotenName\n \n if posS :\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n if posE:\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\n \n MaxKnotenLeitung = max(KnotenLeitung)\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\n \n for ii in list(range(0, MaxKnotenLeitung + 1)):\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\n\n\n return HistSegmKnoten","def graph_fo_relation(self, universe):\n return FO_Relation([tuple(row) for row in self.table()], universe)","def cassandra_histograms(mycluster=RING_1_dev__allnodes):\n cassandra_nodetool(mycluster,cmd=\"cfhistograms\")","def compare_histograms(categorical_var, numerical_var):\n pass","def adjList(self, relations):\n adj = {}\n for agent in self.agents:\n adj[agent] = {}\n for agent in self.agents:\n for relation in relations[agent]:\n if relation[0] not in adj[agent].keys():\n adj[agent][relation[0]] = []\n adj[agent][relation[0]].append(relation[1])\n return adj","def plot_histograms(top, bot, edges, resolution, *, ax=None):\n if ax is None:\n ax = plt.gca()\n\n ax.hlines(y=0,\n xmin=0,\n xmax=1,\n linestyle='dashed',\n color='black',\n alpha=0.2)\n ax.bar(edges, top, width=resolution)\n ax.bar(edges, -bot, width=resolution)\n # Set some sensible defaults - these can be overridden after the fact,\n # since we return the axes object\n ax.set_xlim((-0.05, 1.05))\n ax.set_xlabel('Predicted Probability')\n height = max(abs(x) for x in ax.get_ylim())\n ax.set_ylim((-height, height))\n ax.set_ylabel('Count')\n return ax","def generate_formula_histogram(self):\n\n histogram = dict()\n for element in self.atomelements:\n if element in histogram.keys():\n histogram[element] += 1\n else:\n histogram[element] = 1\n return histogram","def histogram(self):\n return self._hist","def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2","def relations_table(relations):\r\n result = \"<table id='relation_result'>\"\r\n for relation in relations:\r\n result += \"<tr><td>\" + relation + \"</td></tr>\"\r\n result += \"</table>\"\r\n return result","def iGraphFromTuples(association_tuples):\n \n# #get unique words\n# vocab = set()\n# uppercase_tuples = []\n# for (s,r), stren in association_tuples:\n# uppercase_tuples.append((s.upper(), r.upper(), stren))\n# vocab.update(word_pair)\n \n# vocab = list(vocab) #convert to ordered list\n# \n# \n# graph = Graph(len(vocab), directed=True)\n# graph.vs[\"name\"] = vocab #set vertex names\n# edges, _ = zip(*association_tuples)\n# graph.add_edges(edges)\n #association_tuples = [(s.upper(),r.upper(),stren) for (s,r), stren in association_tuples]\n association_tuples = [(s,r,stren) for (s,r), stren in association_tuples]\n graph = Graph.TupleList(association_tuples, directed=True, weights=True)\n \n graph.vs[\"id\"] = graph.vs[\"name\"]\n \n #add weights\n# for s, r , stren in association_tuples:\n# graph[(s,r)] = stren\n neg_log_proportions = []\n for e in graph.es:\n neg_log_proportions.append(-log10(e[\"weight\"]))\n \n graph.es[\"-log weight\"] = neg_log_proportions\n \n assoc_object = AssociationIGraph()\n assoc_object.graph = graph\n return assoc_object","def histogram(self, mask=None, extrema=None):\r\n uni, counts = self._getcolors()\r\n return [l for l in counts]","def read_graph(args):\n dataset = pd.read_csv(args.features_path).values.tolist()\n edges = {}\n edges[\"positive_edges\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\n edges[\"negative_edges\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\n edges[\"ecount\"] = len(dataset)\n edges[\"ncount\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\n return edges","def plot_pol_edge_counts(double_pol):\n pol_subs = load_pol_subs()\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\','')\n subreddits = pol_subs.subreddit\n pol_subs = pol_subs.set_index('subreddit')\n \n el = double_pol[['source','target','resid']]\n el_copy = el.copy()\n el_copy.columns = ['target','source','resid']\n\n pe = pd.concat([el,el_copy])\n pol_subs['num_pol_edges'] = pe.source.value_counts()\n pol_subs = pol_subs.sort_values('num_pol_edges',ascending=True)\n pol_subs['num_pol_edges'].plot(kind='barh',color=pol_subs['col'])\n\n plt.xticks(np.arange(0, 22, 2.0))\n plt.tight_layout()\n plt.savefig(figures_path(f\"{date}/pol_edge_counts.png\"))","def _get_sup_relations(user):\n global sup_relations, nk_stat\n rel_support_datasets = os.listdir(\"temp/relation_support_datasets\") #gets a list of the relation support datasets\n rel_support_datasets = sorted([i for i in rel_support_datasets if '.csv' in i and user.username in i])\n sup_relations = []\n nk_stat = []\n for f in rel_support_datasets:\n df = pd.read_csv(\"temp/relation_support_datasets/\"+f, engine='python')\n sup_relations.append(\", \".join(list(df['reldescription'].unique())))\n N = df['reldescription'].unique().shape[0]\n K = df[df['reldescription'] == df['reldescription'].loc[0]].shape[0]\n \n nk_stat.append(\"{}-way {}-shot\".format(N, K))","def _fast_hist(data, bin_edges):\n # Yes, I've tested this against histogram().\n return np.bincount(np.digitize(data, bin_edges[1:-1]), minlength=len(bin_edges) - 1)","def make_histograms(lengths, binwidth=10):\r\n min_len = min(lengths)\r\n max_len = max(lengths)\r\n floor = (min_len / binwidth) * binwidth\r\n ceil = ((max_len / binwidth) + 2) * binwidth\r\n bins = arange(floor, ceil, binwidth)\r\n hist, bin_edges = histogram(lengths, bins)\r\n return hist, bin_edges","def histogram_genres(our_data):\n genre_list = []\n for album in our_data:\n genre_list.extend(genre.strip() for genre in album['genre'].split(','))\n genre_dict = {}\n for genre in genre_list:\n if genre in genre_dict:\n genre_dict[genre] += 1\n else:\n genre_dict[genre] = 1\n return genre_dict","def histogram(self, data):\n histogram_keys = ['bins', 'color', 'alpha', 'label']\n histogram_config = self.config.filter(histogram_keys, prefix='histogram_')\n\n _, _, bar = self.ax.hist(data, **histogram_config)\n\n return [bar]","def describe_graph(g):\n print(\"Order: {} nodes\".format(g.number_of_nodes()))\n print(\"Max node id: {}\".format(max([n for n in g.nodes()])))\n print(\"Size: {} edges (interactions)\".format(g.number_of_edges()))\n print(\"Density: {}\".format(nx.density(g)))\n ts = nx.get_edge_attributes(g, 'start')\n ds = nx.get_edge_attributes(g, 'duration')\n print(\"First timestamp is: {}\".format(min(ts.values())))\n print(\"Last timestamp is: {}\".format(max([ts[k] + ds[k] for k in ts.keys()])))","def GetInOutRelationshipsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if rel in r[2]]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if rel in r[2]]\n res[gc.InputRelations][rel] = inRelations\n return res","def draw_histogram(graph: Graph) -> Optional[Graph]:\n if not graph:\n return None\n try:\n # generate and open a new figure\n figure, ax = plt.subplots()\n # When graph.x or y is str, the histogram is ill-defined.\n ax.barh(graph.y, graph.x, color=graph.color)\n ax.set_title(graph.title)\n if graph.xlabel:\n ax.set_xlabel(graph.xlabel)\n if graph.ylabel:\n ax.set_ylabel(graph.ylabel)\n for index, value in enumerate(graph.x):\n show_value = f'{value:.2f}' if isinstance(value, float) else value\n # To avoid the number has overlap with the box of the graph.\n if value > 0.9 * max(graph.x):\n ax.text(\n value - (value / 10), index, show_value, va='center', color='w'\n )\n else:\n ax.text(value, index, show_value, va='center')\n\n graph.figure = figure\n graph.base64str = figure_to_base64str(figure)\n except TypeError as e:\n logging.info('skipping %s for histogram; plot error: %s:', graph.name, e)\n return None\n finally:\n # closes the figure (to limit memory consumption)\n plt.close()\n return graph","def graph(self) -> dict:\n return self.flat_graph()","def histograms(self, *args, **kwargs):\n return _image.image_histograms(self, *args, **kwargs)","def graph(g):\n return str(g.adjacencyList())","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def dp_histogram(data, edges=None, categories=None, null_value=None, lower=0, upper=None, inclusive_left=True, mechanism=\"SimpleGeometric\", privacy_usage=None, **kwargs):\n return Component(\n \"DPHistogram\",\n arguments={\n 'data': Component.of(data),\n 'edges': Component.of(edges, value_format=\"jagged\"),\n 'categories': Component.of(categories, value_format=\"jagged\"),\n 'null_value': Component.of(null_value),\n 'lower': Component.of(lower),\n 'upper': Component.of(upper),\n 'inclusive_left': Component.of(inclusive_left)\n },\n options={\n 'mechanism': mechanism,\n 'privacy_usage': serialize_privacy_usage(privacy_usage)\n },\n constraints=kwargs)","def graphs(self):\n return self.__graphs","def histogram(end_statistics: EndStatistics, n: int, gc_content: float) -> str:\n sio = StringIO()\n\n print(\"length\", \"count\", \"expect\", \"max.err\", \"error counts\", sep=\"\\t\", file=sio)\n for row in histogram_rows(end_statistics, n, gc_content):\n print(\n row.length,\n row.count,\n f\"{row.expect:.1F}\",\n row.max_err,\n \" \".join(str(e) for e in row.error_counts),\n sep=\"\\t\",\n file=sio,\n )\n return sio.getvalue() + \"\\n\"","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def test_find_relation_types(self):\n pass","def test_get_relation_type(self):\n pass","def getrelations(self):\n return self.getfieldnames('ONE')","def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\"rel\"):\n s, o = int(s.id), int(o.id)\n yield {\"predicate\": p,\n \"subject\": s,\n \"subject_nodes\": list(self.get_descendants(s, triples)),\n \"object\": o,\n \"object_nodes\": list(self.get_descendants(o, triples)),\n }","def getHistogram(self, copy: bool=True):\n for item in self.getPlotWidget().getItems():\n if item.getName() == 'histogram':\n return (item.getValueData(copy=copy),\n item.getBinEdgesData(copy=copy))\n else:\n return None","def graph_dict2graph(self, graph_dict):\n\t\tno2index = {}\t\t#used to keep track of whether one node has appeared or not\n\t\tindex2no = {}\n\t\tgraph = Graph.Graph()\n\t\tno_of_genes = 0\n\t\tfor (edge, weight) in graph_dict.iteritems():\n\t\t\tif edge[0] not in no2index:\n\t\t\t\tindex1 = no_of_genes\n\t\t\t\tno2index[edge[0]] = index1\t\t\t\t\n\t\t\t\tindex2no[index1] = edge[0]\n\t\t\t\tno_of_genes += 1\n\t\t\telse:\n\t\t\t\tindex1 = no2index[edge[0]]\n\t\t\t\t\n\t\t\tif edge[1] not in no2index:\n\t\t\t\tindex2 = no_of_genes\n\t\t\t\tno2index[edge[1]] = index2\n\t\t\t\tindex2no[index2] = edge[1]\n\t\t\t\tno_of_genes += 1\n\t\t\telse:\n\t\t\t\tindex2 = no2index[edge[1]]\n\t\t\tif index1<index2:\n\t\t\t\tgraph.add_edge(index1, index2, weight)\n\t\t\telse:\n\t\t\t\tgraph.add_edge(index2, index1, weight)\n\t\t\n\t\treturn (index2no, graph)","def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2","def ListConceptRelations(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def in_degree_distribution(graph):\n in_degrees = collections.Counter()\n for node in graph.nodes(data=True):\n in_degrees[graph.in_degree(node[0])] += 1\n\n in_degrees = sorted(in_degrees.items(), key=lambda x: x[0])\n\n print(in_degrees)","def relations(self):\n\n def functions_helper(returned_set: set()):\n if is_relation(self.root): # Populate self.root and self.arguments\n returned_set.add((self.root, len(self.arguments)))\n\n elif is_equality(self.root): # Populate self.first and self.second\n return\n elif is_quantifier(self.root): # Populate self.variable and self.predicate\n returned_set.update(self.predicate.relations())\n\n elif is_unary(self.root): # Populate self.first\n returned_set.update(self.first.relations())\n\n else: # Populate self.first and self.second\n returned_set.update(self.first.relations())\n returned_set.update(self.second.relations())\n return\n\n \"\"\" Return a set of pairs (function_name, arity) for all function names\n that appear in this formula \"\"\"\n returned_set = set()\n functions_helper(returned_set)\n return returned_set\n\n # Ex12","def type_count():\n types = []\n for typ in Statistics.all_type():\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\n fix_types = []\n for i in sorted(types, key=lambda k: k['y']):\n if i['y'] != 0:\n fix_types.append(i)\n return jsonify(result=fix_types)","def table_graph(self, i):\n return self.__graph_list[i]","def test_get_histogram_stat_by(self):\n pass","def histogramintegrals(self):\n return {}","def getHistogram(self, var, idx = None, translation = None, other = None,\\\n verbose = 1, ab = [], bins = 100, minmax = None):\n \n if idx is None: idx = np.arange(self.atoms.shape[0])\n if translation is None: translation = [0]\n if isinstance(translation, (int, np.integer)): translation = [translation]\n\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\n verbose = verbose, ab = ab, other = other)\n x = []\n y = []\n for i, item in enumerate(data):\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\n x.append((bin[:-1] + bin[1:]) / 2)\n y.append(cnt)\n\n return x, y, lbl, leg","def std_triangles_count(graph):\n if nx.is_directed(graph):\n raise Exception(\"Graph is not undirected\")\n\n return sum(nx.triangles(graph).values()) // 3","def calculate_histograms_from_assignments(self, funcs, bin_size=1):\n result = defaultdict(lambda: defaultdict(\n lambda: Histogram(bin_size)\n ))\n for assignment in self.get_assignment_reader():\n for name, func in funcs.iteritems():\n value = func(assignment)\n if value is None:\n continue\n result[name][assignment.source].add(value)\n return result","def visualize_type():\n\t\n\t#grab our parsed data\n\tdata_file = parse(MY_FILE, \",\")\n\t\n\t#make a new variable, counter, from iterating through each line of\n\t#data in parsed data, and count how many incidents happen by category\n\tcounter = Counter(item[\"Category\"] for item in data_file)\n\t\n\t#set the labels which are based on the keys of our counter\n\t#since order doesn't matter, we can just use counter.keys()\n\tlabels = tuple(counter.keys())\n\t\n\t#set exactly where the labels should hit the x-axis\n\txlocations = np.arange(len(labels)) + 0.5\n\t\n\t#width of each bar that will be plotted\n\twidth = 0.5\n\t\n\t#assign data to a bar plot\n\tplt.bar(xlocations, counter.values(), width=width)\n\t\n\t#assign labels and tick location to x-axis\n\tplt.xticks(xlocations + width /2, labels, rotation=90)\n\t\n\t#give more room to the x-axis so the labels aren't cut off\n\tplt.subplots_adjust(bottom=0.4)\n\t\n\t#make the overall graph/figure larger\n\tplt.rcParams['figure.figsize'] = 12, 8\n\t\n\t#save the graph\n\tplt.savefig(\"type.png\")\n\t\n\t#close the plot figure\n\tplt.clf()","def get_indegrees(graph: Graph):\n transpose = get_transpose_graph(graph)\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}","def rdf(bin_edges, r, V):\n N = r.shape[0]\n bin_centres = 0.5 * (bin_edges[1:] + bin_edges[:-1])\n bin_sizes = bin_edges[1:] - bin_edges[:-1]\n n = np.zeros_like(bin_sizes)\n for i in range(N):\n if i % 1000 == 0:\n print(f\"Binning {i} of {N} distances, {100*(i/N):11.3f}% commplete\")\n dr = np.linalg.norm(r - r[i], axis=1) # Distances from atom i.\n n += np.histogram(dr, bins=bin_edges)[0] # Count atoms within each\n # distance interval.\n n[0] = 0\n \n # Equation (7) on the preceding page:\n rdf = V / N**2 * n / (4 * np.pi * bin_centres**2 * bin_sizes)\n return rdf","def result_count(sol,Nt,G):\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq","def find_relationships(self, fig1, fig2):\r\n \r\n rels = []\r\n \r\n # relationship based on # of objects\r\n if len(fig1) == len(fig2):\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\r\n else:\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\r\n \r\n for obj, attrs in fig1.items():\r\n if not obj in fig2:\r\n # object has been removed in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\r\n continue\r\n \r\n for obj in fig2:\r\n if not obj in fig1:\r\n # object is only present in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\r\n continue\r\n \r\n for attr in fig2[obj]:\r\n rel = {'obj': obj, 'attr': attr}\r\n \r\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\r\n rel['type'] = 'match'\r\n else:\r\n partial_match = False\r\n for subvalue in fig2[obj][attr]:\r\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\r\n partial_match = True\r\n \r\n if partial_match:\r\n rel['type'] = 'partial'\r\n else:\r\n rel['type'] = 'mismatch'\r\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\r\n rel['new_values'] = ','.join(fig2[obj][attr])\r\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\r\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\r\n del rel['old_values']\r\n del rel['new_values']\r\n \r\n rels.append(rel)\r\n \r\n return rels","def result_count(sol,Nt,G):\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq","def format_histogram_one_count(counts, bin_edges):\r\n lines = []\r\n lines.append('Length\\tCount')\r\n for edge, count in zip(bin_edges, counts):\r\n lines.append('\\t'.join(map(str, [edge, count])))\r\n return '\\n'.join(lines)","def get_undirected_edges(mapping, G):\n edge_types = utils.rels_types\n edges = {}\n for et in edge_types:\n edges[et] = {}\n for g in G.nodes:\n edges[et][mapping[g]] = []\n for s, t, meta in G.edges(data=True):\n #print(s, t)\n edges[meta['type']][mapping[s]].append(mapping[t])\n edges[meta['type']][mapping[t]].append(mapping[s])\n return edges","def hist(x, bins='auto', range=None, weights=None, errorbars=False, normed=False, scale=None,\n stacked=False, histtype='stepfilled', **kwargs):\n\n # Generate a histogram object\n\n hist_con = HistContainer(x, bins, range, weights, errorbars, normed, scale, stacked,\n histtype, **kwargs)\n\n if hist_con.err_return:\n return hist_con.bin_content, hist_con.bin_edges, hist_con.bin_err, hist_con.vis_object\n else:\n return hist_con.bin_content, hist_con.bin_edges, hist_con.vis_object","def plot_hist(self):\n labels = [self.get_class_str(action, obj)\n for (action, obj, subj, rec, beg, end) in self.action_clips]\n visualize.plot_hist(labels, proportion=True)","def relationship_count(self, r_type=None, n_ids=()):\n if r_type is None and not n_ids:\n return len(self._relationships)\n elif not n_ids:\n return len(self._relationships_by_type.get(r_type, ()))\n else:\n return sum(1 for _ in self.relationships(r_type, n_ids))","def gen_graph(self):","def read_nell_relations():\n\trel=os.walk(\"nell/relations\")\n\trelation=[]\n\tfor i in rel:\n\t\ttrel=i[2]\n\tfor i in trel:\n\t\trelation.append(' '.join(segment(i.split(':')[1])))\n\treturn relation","def relations(cls):\n return [c.key for c in cls.__mapper__.iterate_properties\n if isinstance(c, RelationshipProperty)]","def get_relation_by_concept(self, concept_mention, domain_simple_name):\n\n chosen_domain = self.db.session.query(Domain).filter(Domain.simple_name==domain_simple_name).one()\n candidate_relations = self.db.session.query(Relation).filter(Relation.domains.contains(chosen_domain)).all()\n items = self.db.session.query(Item)\\\n .filter(or_(Item.c1.like(concept_mention + \"%\"), Item.c2.like(concept_mention + \"%\")))\\\n .all()\n\n candidate_relations = [r.simple_name for r in candidate_relations]\n items = filter(lambda x: x.relation in candidate_relations, items)\n\n rel_counts = dict(zip(candidate_relations, [0]*len(candidate_relations)))\n for i in items:\n if not i.relation in rel_counts:\n rel_counts[i.relation]=0\n rel_counts[i.relation]+=1\n\n print(rel_counts)\n rel_counts = filter(lambda x: x[0] in candidate_relations,rel_counts.items())\n rel_counts = sorted(rel_counts, key=lambda x: x[1])\n\n assert len(rel_counts)>0\n chosen_relation = rel_counts[0][0]\n return chosen_relation","def getHistogramData(self):\n return (self.numBins, self.binWidth, self.minFreq, self.maxFreq)","def _fast_hist_2d(data, bin_edges):\n # Yes, I've tested this against histogramdd().\n xassign = np.digitize(data[:,0], bin_edges[1:-1]) \n yassign = np.digitize(data[:,1], bin_edges[1:-1])\n nbins = len(bin_edges) - 1\n flatcount = np.bincount(xassign + yassign * nbins, minlength=nbins*nbins)\n return flatcount.reshape((nbins, nbins))","def rwgraph_analyze1(input=(None)):\r\n #generates graph\r\n n=2000\r\n m=4\r\n G=nx.barabasi_albert_graph(n, m, seed=5)\r\n\r\n Nt=100\r\n M=20000\r\n #finds max degree of graph and stores list of degrees of nodes\r\n maxdeg=0\r\n degree_dist=[]\r\n for i in range(0,n):\r\n degree_dist.append(G.degree[i])\r\n if G.degree[i]>maxdeg:\r\n maxdeg=G.degree[i]\r\n j=i\r\n #generates data and stores them in lists for varyin M and Nt\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes=[]\r\n for i in range(M):\r\n Listnodes.append(G.degree(X[i,Nt]))\r\n Nt=10000\r\n M=20000\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes2=[]\r\n for i in range(M):\r\n Listnodes2.append(G.degree(X[i,Nt]))\r\n Nt=10\r\n M=20000\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes3=[]\r\n for i in range(M):\r\n Listnodes3.append(G.degree(X[i,Nt]))\r\n Nt=10000\r\n M=200\r\n X=rwgraph(G,j,M,Nt)\r\n Listnodes4=[]\r\n for i in range(M):\r\n Listnodes4.append(G.degree(X[i,Nt]))\r\n fig, ax1 = plt.subplots(figsize =(14,7))\r\n\r\n ##### creates histo gram figure with 2 axis####\r\n ax1.hist([Listnodes,Listnodes2], bins=maxdeg, label=['Nt=100', 'Nt=10000'],color=['g','r'],alpha=0.6)\r\n ax1.set_xlabel('degree of node')\r\n ax1.set_ylabel('frequency of final position of random walks')\r\n\r\n ax1.tick_params(axis='y')\r\n ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\r\n\r\n ax2.hist([degree_dist], bins=maxdeg, label=['graph node frequency'],color=['b'],alpha=0.6)\r\n ax2.set_ylabel('frequency of node degrees for graph')\r\n ax2.tick_params(axis='y')\r\n\r\n ax1.legend(loc=\"center right\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n ax2.legend(loc=\"upper right\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title('M=20000, node degree of final position of random walk, for varying amounts of time', y=1.10, fontsize=20)\r\n fig.tight_layout() # otherwise the right y-label is slightly clipped\r\n plt.grid(b=None)\r\n plt.show()\r\n\r\n #function to generate diction of frequency\r\n def CountFrequency(my_list):\r\n\r\n # Creating an empty dictionary\r\n freq = {}\r\n for item in my_list:\r\n if (item in freq):\r\n freq[item] += 1\r\n else:\r\n freq[item] = 1\r\n return freq\r\n #converts data to approprate form so it can plotted on scatter plot\r\n #frequecy\r\n listfreq1=CountFrequency(Listnodes2)\r\n listfreq2=CountFrequency(Listnodes3)\r\n listfreq3=CountFrequency(Listnodes4)\r\n listfreq_deg=CountFrequency(degree_dist)\r\n #set up lists\r\n z=[]\r\n z2=[]\r\n z3=[]\r\n z_deg=[]\r\n z_deg2=[]\r\n z_deg3=[]\r\n #code to create list of only degrees used in simulations\r\n for i in listfreq1:\r\n z.append(listfreq1[i]/(listfreq_deg[i]*20000))\r\n z_deg.append(i)\r\n for i in listfreq2:\r\n z2.append(listfreq2[i]/(listfreq_deg[i]*20000))\r\n z_deg2.append(i)\r\n for i in listfreq3:\r\n z3.append(listfreq3[i]/(listfreq_deg[i]*200))\r\n z_deg3.append(i)\r\n #extpected prob distribution\r\n E=G.number_of_edges()\r\n z0=[]\r\n z_deg0=[]\r\n for i in listfreq_deg:\r\n z0.append(i/(2*E))\r\n z_deg0.append(i)\r\n #genrates scatter plot figure\r\n plt.figure(figsize=(12, 6))\r\n plt.scatter(z_deg, z, label='Nt=10000, M=20000')\r\n plt.scatter(z_deg2, z2,label='Nt=10, M=20000')\r\n plt.scatter(z_deg3, z3,label='Nt=10, M=200')\r\n plt.plot(z_deg0,z0,label=\"expected prob dist\",alpha=0.5)\r\n plt.xlabel('degree of node')\r\n plt.ylabel('frequency of final position / M*frequency of degree')\r\n plt.legend(loc=\"upper left\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\r\n plt.title(\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\")\r\n plt.show()\r\n return None #modify as needed\r","def get_number_of_relations(model):\n if model == None:\n return 0\n counter = 0\n for line in model:\n if line.find('f(2') >= 0:\n counter += 1\n return float(counter)\n #TODO when multiples of same relation, the result is still 1","def graph_diameter(variables, relations):\n diams = []\n g = as_networkx_graph(variables, relations)\n components = (g.subgraph(c).copy() for c in nx.connected_components(g))\n for c in components:\n diams.append(nx.diameter(c))\n\n return diams","def histogram(self, image):\n\n response = self._send_request(\"histogram\", files=dict(image=image))\n return response[self._layer]['histogram']","def ngraphs(self):\n return len(self.__graph_list)","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def relations(self):\n\t\treturn [(self.factions[k][0], self._faction_affinity.get(k, 50)) for k in self.factions.keys()]","def analyze_edges_and_weight(list_of_nodes):\n edges_info = []\n for node in list_of_nodes:\n n_edge_of_node = len(node.neighbors) # Counts the kys in the dictionary 'Node.neighbors'\n total_weight_of_node = sum(list(map(lambda x: node.neighbors[x], node.neighbors))) # Sums values of the dict\n node_info = (node.name, n_edge_of_node, total_weight_of_node)\n edges_info.append(node_info)\n total_n_edges = sum([tup[1] for tup in edges_info]) # Sum total number of edges\n total_weight_of_graph = sum([tup[2] for tup in edges_info]) # Sum total weight of edges\n sorted_info = sorted(edges_info, key=lambda tup: tup[1], reverse=True)\n return \"Total number of edges is {},\\nTotal weight of the graph is {}:\\nNodes sorted by no. of edges: {}.\".format(total_n_edges, total_weight_of_graph, sorted_info)","def test_ontology_term_graph_based_information_content(ontology):\n\tassert ontology.ic(\"TO:0000001\", as_weight=False) == 0.000\n\tassert ontology.ic(\"TO:0000002\", as_weight=False) == 0.3690702464285426\n\tassert ontology.ic(\"TO:0000003\", as_weight=False) == 0.3690702464285426\n\tassert ontology.ic(\"TO:0000004\", as_weight=False) == 1.000\n\tassert ontology.ic(\"TO:0000005\", as_weight=False) == 3.000\n\tassert ontology.ic(\"TO:0000006\", as_weight=False) == 3.000\n\tassert ontology.ic(\"TO:0000007\", as_weight=False) == 0.500\n\tassert ontology.ic(\"TO:0000008\", as_weight=False) == 1.3690702464285427\n\tassert ontology.ic(\"TO:0000009\", as_weight=False) == 3.000","def format_out_relations(relations, out_):\n\n if out_ == 'sparse':\n relations_o = relations\n elif out_ == 'network':\n relations_o = nx.from_scipy_sparse_matrix(relations)\n elif out_ == 'sp_relations':\n relations_o = RegionDistances(relations)\n elif out_ == 'list':\n relations_o = []\n for i in range(relations.shape[0]):\n relations_o.append(list(relations.getrow(i).nonzero()[0]))\n return relations_o","def _get_graph_based_ic_dictionary(self):\n\n\t\t# TODO find the literature reference or presentation where this equation is from instead of just the presentation.\n\n\t\t#ic_dict = {}\n\t\t#num_terms_in_ontology = len(self)\n\t\t#for term in self.terms():\n\t\t#\tdepth = self._depth_dict[term.id]\n\t\t#\tnum_descendants = len(list(term.subclasses(with_self=False)))\n\t\t#\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\n\t\t#\tic_dict[term.id] = ic_value\n\t\t#return(ic_dict)\n\n\n\t\t# Getting the information content of each term in the ontology based on graph structure.\n\t\tic_dict = {}\n\t\tnum_terms_in_ontology = len(self)\n\t\tfor term in self.terms():\n\t\t\tdepth = self._depth_dict[term.id]\n\t\t\tnum_descendants = len(list(term.subclasses(with_self=False)))\n\t\t\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\n\t\t\tic_dict[term.id] = ic_value\n\n\n\t\t# Converting to weights based on information content rather than raw value.\n\t\tic_dict_as_weights = {}\n\t\tic_values = ic_dict.values()\n\t\tmin_ic = min(ic_values)\n\t\tmax_ic = max(ic_values)\n\t\tnew_max = 1.00\n\t\tnew_min = 0.00\n\t\tfor k,v in ic_dict.items():\n\t\t\told_range = max_ic-min_ic\n\t\t\tnew_range = new_max-new_min\n\t\t\tnew_value = (((v - min_ic) * new_range) / old_range) + new_min\n\t\t\tic_dict_as_weights[k] = new_value\n\n\t\treturn(ic_dict, ic_dict_as_weights)","def edges(self, irc, msg, args, channel):\n pie = self.instances[irc.network]\n irc.reply([str(x) for x in pie.graphs[channel].edges.values()])","def showOrHideHistogramControls(graphType:int):\n\n\tif GRAPHTYPE_CHOICES[graphType] == 'Histogram':\n\t\treturn {'display': 'block'}\n\treturn {'display': 'none'}","def iter_stats_graph(graph: tfgnn.GraphTensor) -> Iterator[Tuple[str,\n tfgnn.Field]]:\n\n for set_type, set_name, set_obj in tfgnn.iter_sets(graph):\n if set_type != tfgnn.CONTEXT:\n # Output a feature for the size of the set.\n key = f\"{set_type}/{set_name}/{tfgnn.SIZE_NAME}\"\n yield key, set_obj.sizes\n\n # Output the values for each feature.\n for feature_name, tensor in set_obj.features.items():\n if tensor.dtype == tf.string:\n continue\n key = f\"{set_type}/{set_name}/{feature_name}\"\n yield key, tensor","def as_networkx_graph(variables, relations):\n graph = nx.Graph()\n\n # One node for each variables\n graph.add_nodes_from([v.name for v in variables])\n\n for r in relations:\n for p in all_pairs([e.name for e in r.dimensions]):\n graph.add_edge(*p)\n return graph","def database_statistics(database):\n\tglobal_node_counter = 0\n\tglobal_edge_counter = 0\n\tn_graphs = 0\n\tfor i, g in enumerate(database):\n\t\tfor n in g.nodes:\n\t\t\tglobal_node_counter += 1\n\t\t\tfor e in n.edges:\n\t\t\t\tglobal_edge_counter += 1\n\t\tn_graphs += 1\n\tavg_node = float(global_node_counter) / n_graphs\n\tavg_edge = float(global_edge_counter) / n_graphs\n\treturn avg_node, avg_edge"],"string":"[\n \"def count_relations(graph):\\n return Counter(\\n data[RELATION]\\n for _, _, data in graph.edges_iter(data=True)\\n )\",\n \"def relationship_types(self):\\n return frozenset(self._relationships_by_type.keys())\",\n \"def get_all_relations(graph, u, v):\\n return {\\n data[RELATION]\\n for data in graph.edge[u][v].values()\\n }\",\n \"def bins(G):\\n bins = {}\\n for i in range(0, len(G.nodes(\\\"binary\\\")[0])+1):\\n bins[i] = []\\n\\n for node in range(len(list(G.nodes()))):\\n node_attr = G.node[node]\\n # Calculate the level of each node\\n level = node_attr[\\\"binary\\\"].count(\\\"1\\\")\\n bins[level].append(node)\\n\\n return bins\",\n \"def count_relation_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\\n for relation in relation_types:\\n if relation in count:\\n count[relation] += 1\\n else:\\n count[relation] = 1\\n return count\",\n \"def hog_histograms(*args, **kwargs): # real signature unknown\\n pass\",\n \"def subtype_counts(node_set, G, log=False):\\n subtypes = Counter()\\n for n in node_set:\\n subtype = G.node[n]['subtype']\\n subtypes[subtype] += 1\\n\\n if log:\\n for k, v in subtypes.items():\\n subtypes[k] = np.log10(v)\\n \\n return subtypes\",\n \"def count_pathologies(graph):\\n return Counter(_pathology_iterator(graph))\",\n \"def histogram_categorical_attribute(nodes: typ.Iterable[vtna.graph.TemporalNode], attribute_name: str) \\\\\\n -> typ.Dict[str, int]:\\n hist = collections.Counter()\\n hist.update(node.get_global_attribute(attribute_name) for node in nodes)\\n return hist\",\n \"def histogram_edges(edges: typ.List[typ.Tuple[int, int, int]], granularity: int=None) -> typ.List[int]:\\n if len(edges) == 0:\\n return list()\\n if granularity is None:\\n granularity = vtna.data_import.infer_update_delta(edges)\\n histogram = [len(ls) for ls in vtna.data_import.group_edges_by_granularity(edges, granularity)]\\n return histogram\",\n \"def PlotDirectedEdgeHistogram(self, g, edgeAttribute=\\\"weight\\\", useLogP1Space=True):\\n\\t\\tseries = []\\n\\t\\tfor e in g.es:\\n\\t\\t\\tsrc = g.vs[e.source][\\\"name\\\"]\\n\\t\\t\\tdest = g.vs[e.target][\\\"name\\\"]\\n\\t\\t\\tif useLogP1Space:\\n\\t\\t\\t\\tedgeValue = np.log(e[edgeAttribute])+1 #add one, simply for plotting\\n\\t\\t\\telse:\\n\\t\\t\\t\\tedgeValue = e[edgeAttribute]\\n\\t\\t\\tpair = (src+\\\"--\\\"+dest, edgeValue)\\n\\t\\t\\tseries.append(pair)\\n\\t\\t\\n\\t\\tprint(str(series))\\n\\t\\tdf = pd.Series([pair[1] for pair in series], index=[pair[0] for pair in series])\\n\\t\\tprint(str(df))\\n\\t\\tprint(\\\"Plotting...\\\")\\n\\t\\tdf.sort_values().plot(kind='bar',title=\\\"Log-Space Host-Host Flow Frequency\\\")\\n\\t\\t#hist.plot()\\n\\t\\tplt.tight_layout()\\n\\t\\tplt.show()\\n\\t\\tplt.clf()\\n\\t\\t\\n\\t\\t#plot outgoing flow distributions, only for vertices with more than one outgoing edge\\n\\t\\tfor v in g.vs:\\n\\t\\t\\tedges = g.es.select(_source=v.index)\\n\\t\\t\\tif len(edges) > 1:\\n\\t\\t\\t\\tprint(str(len(edges)))\\n\\t\\t\\t\\tneighborFrequencies = [(g.vs[e.target][\\\"name\\\"], e[\\\"weight\\\"]) for e in edges]\\n\\t\\t\\t\\tprint(\\\"NEIGHBORS: \\\"+str(neighborFrequencies))\\n\\t\\t\\t\\tseries = pd.Series([pair[1] for pair in neighborFrequencies], index=[pair[0] for pair in neighborFrequencies])\\n\\t\\t\\t\\tseries.sort_values().plot(kind='bar',title=v[\\\"name\\\"]+\\\" Neighbor Flow Frequency\\\")\\n\\t\\t\\t\\tplt.tight_layout()\\n\\t\\t\\t\\tplt.show()\\n\\t\\t\\t\\tplt.clf()\",\n \"def relations(self):\\n return set(self.triples()[\\\"relation\\\"])\",\n \"def degree_histogram_directed(G, in_degree=False, out_degree=False):\\n nodes = G.nodes()\\n if in_degree:\\n in_degree = dict(G.in_degree())\\n degseq=[in_degree.get(k,0) for k in nodes]\\n elif out_degree:\\n out_degree = dict(G.out_degree())\\n degseq=[out_degree.get(k,0) for k in nodes]\\n else:\\n degseq=[v for k, v in G.degree()]\\n dmax=max(degseq)+1\\n freq= [ 0 for d in range(dmax) ]\\n for d in degseq:\\n freq[d] += 1\\n return freq\",\n \"def GetInOutRelationsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def multiple_connections_histogram(synapses):\\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\\n return count_of_synapses\",\n \"def test_make_histograms(self):\\r\\n raw_lengths = [90, 100, 110, 110, 130, 135]\\r\\n pre_lengths = [100, 110, 105, 130, 135]\\r\\n post_lengths = [130, 135]\\r\\n raw_hist, pre_hist, post_hist, bin_edges = \\\\\\r\\n make_histograms(raw_lengths, pre_lengths, post_lengths)\\r\\n assert_almost_equal(pre_hist, array([0, 2, 1, 0, 2]))\\r\\n assert_almost_equal(post_hist, array([0, 0, 0, 0, 2]))\\r\\n assert_almost_equal(bin_edges, array([90, 100, 110, 120, 130, 140]))\",\n \"def hist_of_numeric(X):\\n figsize(10,3)\\n for col in get_numeric(X):\\n print(col)\\n X[col].hist(bins=50)\\n show()\",\n \"def __init__(self, network):\\n self.network = network\\n self.histogram = [0] * (network.maxDegree() + 1)\\n\\n for key, node in network.nodes.items():\\n self.histogram[node.degree()] += 1\\n\\n #print(\\\"Debug: histogram list \\\", self.histogram)\\n\\n # Other option:\\n # Dict containing {id:degree}\\n # self.degrees = {}\\n # for node in network.nodes.iteritems():\\n # self.degrees[node.identifier] = node.degree()\\n # for i in range(0, network.maxDegree() + 1:\\n # self.histogram[i] = self.degrees.values().count(i)\",\n \"def initialize_graph(compound_relations, relation_types):\\n graph = nx.DiGraph()\\n for compound, targets in compound_relations.items():\\n for target, relation in targets.items():\\n if relation in relation_types:\\n graph.add_edge(compound, target)\\n return graph\",\n \"def GetValRelations(self, G, node):\\n res = {gc.InputRelations: [], gc.OutgoingRelations : []}\\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.val in edge[2]]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.val in edge[2]]\\n res[gc.OutgoingRelations] = outEdges\\n res[gc.InputRelations] = inEdges\\n\\n return res\",\n \"def Test_Histogram(Graph_MD):\\n \\n Edges = NX.edges(Graph_MD)\\n KnotenNamen = NX.nodes(Graph_MD)\\n \\n KnotenNamenListe = M_Helfer.unique_String(KnotenNamen)\\n NumKnotenListe = len(KnotenNamenListe)\\n KnotenLeitung = arr.array('i', list(range(1, NumKnotenListe+1)))\\n \\n count = 0\\n for Knoten in KnotenLeitung:\\n KnotenLeitung[count] = 0\\n count = count + 1\\n \\n \\n for ii in list(range(NumKnotenListe)):\\n KnotenName = KnotenNamenListe[ii]\\n for edge in Edges:\\n posS = edge[0] == KnotenName\\n posE = edge[1] == KnotenName\\n \\n if posS :\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n if posE:\\n KnotenLeitung[ii] = KnotenLeitung[ii] + 1\\n \\n MaxKnotenLeitung = max(KnotenLeitung)\\n HistSegmKnoten = M_MatLab.zeros('i', MaxKnotenLeitung+1)\\n \\n for ii in list(range(0, MaxKnotenLeitung + 1)):\\n HistSegmKnoten[ii] = len(M_FindPos.find_pos_ValInVector(ii, KnotenLeitung, '=='))\\n\\n\\n return HistSegmKnoten\",\n \"def graph_fo_relation(self, universe):\\n return FO_Relation([tuple(row) for row in self.table()], universe)\",\n \"def cassandra_histograms(mycluster=RING_1_dev__allnodes):\\n cassandra_nodetool(mycluster,cmd=\\\"cfhistograms\\\")\",\n \"def compare_histograms(categorical_var, numerical_var):\\n pass\",\n \"def adjList(self, relations):\\n adj = {}\\n for agent in self.agents:\\n adj[agent] = {}\\n for agent in self.agents:\\n for relation in relations[agent]:\\n if relation[0] not in adj[agent].keys():\\n adj[agent][relation[0]] = []\\n adj[agent][relation[0]].append(relation[1])\\n return adj\",\n \"def plot_histograms(top, bot, edges, resolution, *, ax=None):\\n if ax is None:\\n ax = plt.gca()\\n\\n ax.hlines(y=0,\\n xmin=0,\\n xmax=1,\\n linestyle='dashed',\\n color='black',\\n alpha=0.2)\\n ax.bar(edges, top, width=resolution)\\n ax.bar(edges, -bot, width=resolution)\\n # Set some sensible defaults - these can be overridden after the fact,\\n # since we return the axes object\\n ax.set_xlim((-0.05, 1.05))\\n ax.set_xlabel('Predicted Probability')\\n height = max(abs(x) for x in ax.get_ylim())\\n ax.set_ylim((-height, height))\\n ax.set_ylabel('Count')\\n return ax\",\n \"def generate_formula_histogram(self):\\n\\n histogram = dict()\\n for element in self.atomelements:\\n if element in histogram.keys():\\n histogram[element] += 1\\n else:\\n histogram[element] = 1\\n return histogram\",\n \"def histogram(self):\\n return self._hist\",\n \"def num_edges(g):\\n total_edges_with_duplicates = sum(len(v) for v in g.values())\\n return total_edges_with_duplicates // 2\",\n \"def relations_table(relations):\\r\\n result = \\\"<table id='relation_result'>\\\"\\r\\n for relation in relations:\\r\\n result += \\\"<tr><td>\\\" + relation + \\\"</td></tr>\\\"\\r\\n result += \\\"</table>\\\"\\r\\n return result\",\n \"def iGraphFromTuples(association_tuples):\\n \\n# #get unique words\\n# vocab = set()\\n# uppercase_tuples = []\\n# for (s,r), stren in association_tuples:\\n# uppercase_tuples.append((s.upper(), r.upper(), stren))\\n# vocab.update(word_pair)\\n \\n# vocab = list(vocab) #convert to ordered list\\n# \\n# \\n# graph = Graph(len(vocab), directed=True)\\n# graph.vs[\\\"name\\\"] = vocab #set vertex names\\n# edges, _ = zip(*association_tuples)\\n# graph.add_edges(edges)\\n #association_tuples = [(s.upper(),r.upper(),stren) for (s,r), stren in association_tuples]\\n association_tuples = [(s,r,stren) for (s,r), stren in association_tuples]\\n graph = Graph.TupleList(association_tuples, directed=True, weights=True)\\n \\n graph.vs[\\\"id\\\"] = graph.vs[\\\"name\\\"]\\n \\n #add weights\\n# for s, r , stren in association_tuples:\\n# graph[(s,r)] = stren\\n neg_log_proportions = []\\n for e in graph.es:\\n neg_log_proportions.append(-log10(e[\\\"weight\\\"]))\\n \\n graph.es[\\\"-log weight\\\"] = neg_log_proportions\\n \\n assoc_object = AssociationIGraph()\\n assoc_object.graph = graph\\n return assoc_object\",\n \"def histogram(self, mask=None, extrema=None):\\r\\n uni, counts = self._getcolors()\\r\\n return [l for l in counts]\",\n \"def read_graph(args):\\n dataset = pd.read_csv(args.features_path).values.tolist()\\n edges = {}\\n edges[\\\"positive_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\\n edges[\\\"negative_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\\n edges[\\\"ecount\\\"] = len(dataset)\\n edges[\\\"ncount\\\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\\n return edges\",\n \"def plot_pol_edge_counts(double_pol):\\n pol_subs = load_pol_subs()\\n pol_subs.subreddit=pol_subs.subreddit.str.replace('\\\\\\\\','')\\n subreddits = pol_subs.subreddit\\n pol_subs = pol_subs.set_index('subreddit')\\n \\n el = double_pol[['source','target','resid']]\\n el_copy = el.copy()\\n el_copy.columns = ['target','source','resid']\\n\\n pe = pd.concat([el,el_copy])\\n pol_subs['num_pol_edges'] = pe.source.value_counts()\\n pol_subs = pol_subs.sort_values('num_pol_edges',ascending=True)\\n pol_subs['num_pol_edges'].plot(kind='barh',color=pol_subs['col'])\\n\\n plt.xticks(np.arange(0, 22, 2.0))\\n plt.tight_layout()\\n plt.savefig(figures_path(f\\\"{date}/pol_edge_counts.png\\\"))\",\n \"def _get_sup_relations(user):\\n global sup_relations, nk_stat\\n rel_support_datasets = os.listdir(\\\"temp/relation_support_datasets\\\") #gets a list of the relation support datasets\\n rel_support_datasets = sorted([i for i in rel_support_datasets if '.csv' in i and user.username in i])\\n sup_relations = []\\n nk_stat = []\\n for f in rel_support_datasets:\\n df = pd.read_csv(\\\"temp/relation_support_datasets/\\\"+f, engine='python')\\n sup_relations.append(\\\", \\\".join(list(df['reldescription'].unique())))\\n N = df['reldescription'].unique().shape[0]\\n K = df[df['reldescription'] == df['reldescription'].loc[0]].shape[0]\\n \\n nk_stat.append(\\\"{}-way {}-shot\\\".format(N, K))\",\n \"def _fast_hist(data, bin_edges):\\n # Yes, I've tested this against histogram().\\n return np.bincount(np.digitize(data, bin_edges[1:-1]), minlength=len(bin_edges) - 1)\",\n \"def make_histograms(lengths, binwidth=10):\\r\\n min_len = min(lengths)\\r\\n max_len = max(lengths)\\r\\n floor = (min_len / binwidth) * binwidth\\r\\n ceil = ((max_len / binwidth) + 2) * binwidth\\r\\n bins = arange(floor, ceil, binwidth)\\r\\n hist, bin_edges = histogram(lengths, bins)\\r\\n return hist, bin_edges\",\n \"def histogram_genres(our_data):\\n genre_list = []\\n for album in our_data:\\n genre_list.extend(genre.strip() for genre in album['genre'].split(','))\\n genre_dict = {}\\n for genre in genre_list:\\n if genre in genre_dict:\\n genre_dict[genre] += 1\\n else:\\n genre_dict[genre] = 1\\n return genre_dict\",\n \"def histogram(self, data):\\n histogram_keys = ['bins', 'color', 'alpha', 'label']\\n histogram_config = self.config.filter(histogram_keys, prefix='histogram_')\\n\\n _, _, bar = self.ax.hist(data, **histogram_config)\\n\\n return [bar]\",\n \"def describe_graph(g):\\n print(\\\"Order: {} nodes\\\".format(g.number_of_nodes()))\\n print(\\\"Max node id: {}\\\".format(max([n for n in g.nodes()])))\\n print(\\\"Size: {} edges (interactions)\\\".format(g.number_of_edges()))\\n print(\\\"Density: {}\\\".format(nx.density(g)))\\n ts = nx.get_edge_attributes(g, 'start')\\n ds = nx.get_edge_attributes(g, 'duration')\\n print(\\\"First timestamp is: {}\\\".format(min(ts.values())))\\n print(\\\"Last timestamp is: {}\\\".format(max([ts[k] + ds[k] for k in ts.keys()])))\",\n \"def GetInOutRelationshipsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if rel in r[2]]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if rel in r[2]]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def draw_histogram(graph: Graph) -> Optional[Graph]:\\n if not graph:\\n return None\\n try:\\n # generate and open a new figure\\n figure, ax = plt.subplots()\\n # When graph.x or y is str, the histogram is ill-defined.\\n ax.barh(graph.y, graph.x, color=graph.color)\\n ax.set_title(graph.title)\\n if graph.xlabel:\\n ax.set_xlabel(graph.xlabel)\\n if graph.ylabel:\\n ax.set_ylabel(graph.ylabel)\\n for index, value in enumerate(graph.x):\\n show_value = f'{value:.2f}' if isinstance(value, float) else value\\n # To avoid the number has overlap with the box of the graph.\\n if value > 0.9 * max(graph.x):\\n ax.text(\\n value - (value / 10), index, show_value, va='center', color='w'\\n )\\n else:\\n ax.text(value, index, show_value, va='center')\\n\\n graph.figure = figure\\n graph.base64str = figure_to_base64str(figure)\\n except TypeError as e:\\n logging.info('skipping %s for histogram; plot error: %s:', graph.name, e)\\n return None\\n finally:\\n # closes the figure (to limit memory consumption)\\n plt.close()\\n return graph\",\n \"def graph(self) -> dict:\\n return self.flat_graph()\",\n \"def histograms(self, *args, **kwargs):\\n return _image.image_histograms(self, *args, **kwargs)\",\n \"def graph(g):\\n return str(g.adjacencyList())\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def dp_histogram(data, edges=None, categories=None, null_value=None, lower=0, upper=None, inclusive_left=True, mechanism=\\\"SimpleGeometric\\\", privacy_usage=None, **kwargs):\\n return Component(\\n \\\"DPHistogram\\\",\\n arguments={\\n 'data': Component.of(data),\\n 'edges': Component.of(edges, value_format=\\\"jagged\\\"),\\n 'categories': Component.of(categories, value_format=\\\"jagged\\\"),\\n 'null_value': Component.of(null_value),\\n 'lower': Component.of(lower),\\n 'upper': Component.of(upper),\\n 'inclusive_left': Component.of(inclusive_left)\\n },\\n options={\\n 'mechanism': mechanism,\\n 'privacy_usage': serialize_privacy_usage(privacy_usage)\\n },\\n constraints=kwargs)\",\n \"def graphs(self):\\n return self.__graphs\",\n \"def histogram(end_statistics: EndStatistics, n: int, gc_content: float) -> str:\\n sio = StringIO()\\n\\n print(\\\"length\\\", \\\"count\\\", \\\"expect\\\", \\\"max.err\\\", \\\"error counts\\\", sep=\\\"\\\\t\\\", file=sio)\\n for row in histogram_rows(end_statistics, n, gc_content):\\n print(\\n row.length,\\n row.count,\\n f\\\"{row.expect:.1F}\\\",\\n row.max_err,\\n \\\" \\\".join(str(e) for e in row.error_counts),\\n sep=\\\"\\\\t\\\",\\n file=sio,\\n )\\n return sio.getvalue() + \\\"\\\\n\\\"\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def test_find_relation_types(self):\\n pass\",\n \"def test_get_relation_type(self):\\n pass\",\n \"def getrelations(self):\\n return self.getfieldnames('ONE')\",\n \"def get_relations(self):\\n triples = list(self.get_triples())\\n\\n for s, p, o in triples:\\n if not p.startswith(\\\"rel\\\"):\\n s, o = int(s.id), int(o.id)\\n yield {\\\"predicate\\\": p,\\n \\\"subject\\\": s,\\n \\\"subject_nodes\\\": list(self.get_descendants(s, triples)),\\n \\\"object\\\": o,\\n \\\"object_nodes\\\": list(self.get_descendants(o, triples)),\\n }\",\n \"def getHistogram(self, copy: bool=True):\\n for item in self.getPlotWidget().getItems():\\n if item.getName() == 'histogram':\\n return (item.getValueData(copy=copy),\\n item.getBinEdgesData(copy=copy))\\n else:\\n return None\",\n \"def graph_dict2graph(self, graph_dict):\\n\\t\\tno2index = {}\\t\\t#used to keep track of whether one node has appeared or not\\n\\t\\tindex2no = {}\\n\\t\\tgraph = Graph.Graph()\\n\\t\\tno_of_genes = 0\\n\\t\\tfor (edge, weight) in graph_dict.iteritems():\\n\\t\\t\\tif edge[0] not in no2index:\\n\\t\\t\\t\\tindex1 = no_of_genes\\n\\t\\t\\t\\tno2index[edge[0]] = index1\\t\\t\\t\\t\\n\\t\\t\\t\\tindex2no[index1] = edge[0]\\n\\t\\t\\t\\tno_of_genes += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tindex1 = no2index[edge[0]]\\n\\t\\t\\t\\t\\n\\t\\t\\tif edge[1] not in no2index:\\n\\t\\t\\t\\tindex2 = no_of_genes\\n\\t\\t\\t\\tno2index[edge[1]] = index2\\n\\t\\t\\t\\tindex2no[index2] = edge[1]\\n\\t\\t\\t\\tno_of_genes += 1\\n\\t\\t\\telse:\\n\\t\\t\\t\\tindex2 = no2index[edge[1]]\\n\\t\\t\\tif index1<index2:\\n\\t\\t\\t\\tgraph.add_edge(index1, index2, weight)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tgraph.add_edge(index2, index1, weight)\\n\\t\\t\\n\\t\\treturn (index2no, graph)\",\n \"def compute_num_edges(graph):\\n # return the number of edges\\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2\",\n \"def ListConceptRelations(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def in_degree_distribution(graph):\\n in_degrees = collections.Counter()\\n for node in graph.nodes(data=True):\\n in_degrees[graph.in_degree(node[0])] += 1\\n\\n in_degrees = sorted(in_degrees.items(), key=lambda x: x[0])\\n\\n print(in_degrees)\",\n \"def relations(self):\\n\\n def functions_helper(returned_set: set()):\\n if is_relation(self.root): # Populate self.root and self.arguments\\n returned_set.add((self.root, len(self.arguments)))\\n\\n elif is_equality(self.root): # Populate self.first and self.second\\n return\\n elif is_quantifier(self.root): # Populate self.variable and self.predicate\\n returned_set.update(self.predicate.relations())\\n\\n elif is_unary(self.root): # Populate self.first\\n returned_set.update(self.first.relations())\\n\\n else: # Populate self.first and self.second\\n returned_set.update(self.first.relations())\\n returned_set.update(self.second.relations())\\n return\\n\\n \\\"\\\"\\\" Return a set of pairs (function_name, arity) for all function names\\n that appear in this formula \\\"\\\"\\\"\\n returned_set = set()\\n functions_helper(returned_set)\\n return returned_set\\n\\n # Ex12\",\n \"def type_count():\\n types = []\\n for typ in Statistics.all_type():\\n types.append({'label': typ.lower(), 'y': Statistics.type_count(typ)})\\n fix_types = []\\n for i in sorted(types, key=lambda k: k['y']):\\n if i['y'] != 0:\\n fix_types.append(i)\\n return jsonify(result=fix_types)\",\n \"def table_graph(self, i):\\n return self.__graph_list[i]\",\n \"def test_get_histogram_stat_by(self):\\n pass\",\n \"def histogramintegrals(self):\\n return {}\",\n \"def getHistogram(self, var, idx = None, translation = None, other = None,\\\\\\n verbose = 1, ab = [], bins = 100, minmax = None):\\n \\n if idx is None: idx = np.arange(self.atoms.shape[0])\\n if translation is None: translation = [0]\\n if isinstance(translation, (int, np.integer)): translation = [translation]\\n\\n data, lbl, leg = self.getData(var = var, idx = idx, translation = translation,\\\\\\n verbose = verbose, ab = ab, other = other)\\n x = []\\n y = []\\n for i, item in enumerate(data):\\n cnt, bin = np.histogram(item, bins = bins, range = minmax)\\n x.append((bin[:-1] + bin[1:]) / 2)\\n y.append(cnt)\\n\\n return x, y, lbl, leg\",\n \"def std_triangles_count(graph):\\n if nx.is_directed(graph):\\n raise Exception(\\\"Graph is not undirected\\\")\\n\\n return sum(nx.triangles(graph).values()) // 3\",\n \"def calculate_histograms_from_assignments(self, funcs, bin_size=1):\\n result = defaultdict(lambda: defaultdict(\\n lambda: Histogram(bin_size)\\n ))\\n for assignment in self.get_assignment_reader():\\n for name, func in funcs.iteritems():\\n value = func(assignment)\\n if value is None:\\n continue\\n result[name][assignment.source].add(value)\\n return result\",\n \"def visualize_type():\\n\\t\\n\\t#grab our parsed data\\n\\tdata_file = parse(MY_FILE, \\\",\\\")\\n\\t\\n\\t#make a new variable, counter, from iterating through each line of\\n\\t#data in parsed data, and count how many incidents happen by category\\n\\tcounter = Counter(item[\\\"Category\\\"] for item in data_file)\\n\\t\\n\\t#set the labels which are based on the keys of our counter\\n\\t#since order doesn't matter, we can just use counter.keys()\\n\\tlabels = tuple(counter.keys())\\n\\t\\n\\t#set exactly where the labels should hit the x-axis\\n\\txlocations = np.arange(len(labels)) + 0.5\\n\\t\\n\\t#width of each bar that will be plotted\\n\\twidth = 0.5\\n\\t\\n\\t#assign data to a bar plot\\n\\tplt.bar(xlocations, counter.values(), width=width)\\n\\t\\n\\t#assign labels and tick location to x-axis\\n\\tplt.xticks(xlocations + width /2, labels, rotation=90)\\n\\t\\n\\t#give more room to the x-axis so the labels aren't cut off\\n\\tplt.subplots_adjust(bottom=0.4)\\n\\t\\n\\t#make the overall graph/figure larger\\n\\tplt.rcParams['figure.figsize'] = 12, 8\\n\\t\\n\\t#save the graph\\n\\tplt.savefig(\\\"type.png\\\")\\n\\t\\n\\t#close the plot figure\\n\\tplt.clf()\",\n \"def get_indegrees(graph: Graph):\\n transpose = get_transpose_graph(graph)\\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}\",\n \"def rdf(bin_edges, r, V):\\n N = r.shape[0]\\n bin_centres = 0.5 * (bin_edges[1:] + bin_edges[:-1])\\n bin_sizes = bin_edges[1:] - bin_edges[:-1]\\n n = np.zeros_like(bin_sizes)\\n for i in range(N):\\n if i % 1000 == 0:\\n print(f\\\"Binning {i} of {N} distances, {100*(i/N):11.3f}% commplete\\\")\\n dr = np.linalg.norm(r - r[i], axis=1) # Distances from atom i.\\n n += np.histogram(dr, bins=bin_edges)[0] # Count atoms within each\\n # distance interval.\\n n[0] = 0\\n \\n # Equation (7) on the preceding page:\\n rdf = V / N**2 * n / (4 * np.pi * bin_centres**2 * bin_sizes)\\n return rdf\",\n \"def result_count(sol,Nt,G):\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\",\n \"def find_relationships(self, fig1, fig2):\\r\\n \\r\\n rels = []\\r\\n \\r\\n # relationship based on # of objects\\r\\n if len(fig1) == len(fig2):\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\\r\\n else:\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\\r\\n \\r\\n for obj, attrs in fig1.items():\\r\\n if not obj in fig2:\\r\\n # object has been removed in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\\r\\n continue\\r\\n \\r\\n for obj in fig2:\\r\\n if not obj in fig1:\\r\\n # object is only present in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\\r\\n continue\\r\\n \\r\\n for attr in fig2[obj]:\\r\\n rel = {'obj': obj, 'attr': attr}\\r\\n \\r\\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\\r\\n rel['type'] = 'match'\\r\\n else:\\r\\n partial_match = False\\r\\n for subvalue in fig2[obj][attr]:\\r\\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\\r\\n partial_match = True\\r\\n \\r\\n if partial_match:\\r\\n rel['type'] = 'partial'\\r\\n else:\\r\\n rel['type'] = 'mismatch'\\r\\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\\r\\n rel['new_values'] = ','.join(fig2[obj][attr])\\r\\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\\r\\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\\r\\n del rel['old_values']\\r\\n del rel['new_values']\\r\\n \\r\\n rels.append(rel)\\r\\n \\r\\n return rels\",\n \"def result_count(sol,Nt,G):\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\",\n \"def format_histogram_one_count(counts, bin_edges):\\r\\n lines = []\\r\\n lines.append('Length\\\\tCount')\\r\\n for edge, count in zip(bin_edges, counts):\\r\\n lines.append('\\\\t'.join(map(str, [edge, count])))\\r\\n return '\\\\n'.join(lines)\",\n \"def get_undirected_edges(mapping, G):\\n edge_types = utils.rels_types\\n edges = {}\\n for et in edge_types:\\n edges[et] = {}\\n for g in G.nodes:\\n edges[et][mapping[g]] = []\\n for s, t, meta in G.edges(data=True):\\n #print(s, t)\\n edges[meta['type']][mapping[s]].append(mapping[t])\\n edges[meta['type']][mapping[t]].append(mapping[s])\\n return edges\",\n \"def hist(x, bins='auto', range=None, weights=None, errorbars=False, normed=False, scale=None,\\n stacked=False, histtype='stepfilled', **kwargs):\\n\\n # Generate a histogram object\\n\\n hist_con = HistContainer(x, bins, range, weights, errorbars, normed, scale, stacked,\\n histtype, **kwargs)\\n\\n if hist_con.err_return:\\n return hist_con.bin_content, hist_con.bin_edges, hist_con.bin_err, hist_con.vis_object\\n else:\\n return hist_con.bin_content, hist_con.bin_edges, hist_con.vis_object\",\n \"def plot_hist(self):\\n labels = [self.get_class_str(action, obj)\\n for (action, obj, subj, rec, beg, end) in self.action_clips]\\n visualize.plot_hist(labels, proportion=True)\",\n \"def relationship_count(self, r_type=None, n_ids=()):\\n if r_type is None and not n_ids:\\n return len(self._relationships)\\n elif not n_ids:\\n return len(self._relationships_by_type.get(r_type, ()))\\n else:\\n return sum(1 for _ in self.relationships(r_type, n_ids))\",\n \"def gen_graph(self):\",\n \"def read_nell_relations():\\n\\trel=os.walk(\\\"nell/relations\\\")\\n\\trelation=[]\\n\\tfor i in rel:\\n\\t\\ttrel=i[2]\\n\\tfor i in trel:\\n\\t\\trelation.append(' '.join(segment(i.split(':')[1])))\\n\\treturn relation\",\n \"def relations(cls):\\n return [c.key for c in cls.__mapper__.iterate_properties\\n if isinstance(c, RelationshipProperty)]\",\n \"def get_relation_by_concept(self, concept_mention, domain_simple_name):\\n\\n chosen_domain = self.db.session.query(Domain).filter(Domain.simple_name==domain_simple_name).one()\\n candidate_relations = self.db.session.query(Relation).filter(Relation.domains.contains(chosen_domain)).all()\\n items = self.db.session.query(Item)\\\\\\n .filter(or_(Item.c1.like(concept_mention + \\\"%\\\"), Item.c2.like(concept_mention + \\\"%\\\")))\\\\\\n .all()\\n\\n candidate_relations = [r.simple_name for r in candidate_relations]\\n items = filter(lambda x: x.relation in candidate_relations, items)\\n\\n rel_counts = dict(zip(candidate_relations, [0]*len(candidate_relations)))\\n for i in items:\\n if not i.relation in rel_counts:\\n rel_counts[i.relation]=0\\n rel_counts[i.relation]+=1\\n\\n print(rel_counts)\\n rel_counts = filter(lambda x: x[0] in candidate_relations,rel_counts.items())\\n rel_counts = sorted(rel_counts, key=lambda x: x[1])\\n\\n assert len(rel_counts)>0\\n chosen_relation = rel_counts[0][0]\\n return chosen_relation\",\n \"def getHistogramData(self):\\n return (self.numBins, self.binWidth, self.minFreq, self.maxFreq)\",\n \"def _fast_hist_2d(data, bin_edges):\\n # Yes, I've tested this against histogramdd().\\n xassign = np.digitize(data[:,0], bin_edges[1:-1]) \\n yassign = np.digitize(data[:,1], bin_edges[1:-1])\\n nbins = len(bin_edges) - 1\\n flatcount = np.bincount(xassign + yassign * nbins, minlength=nbins*nbins)\\n return flatcount.reshape((nbins, nbins))\",\n \"def rwgraph_analyze1(input=(None)):\\r\\n #generates graph\\r\\n n=2000\\r\\n m=4\\r\\n G=nx.barabasi_albert_graph(n, m, seed=5)\\r\\n\\r\\n Nt=100\\r\\n M=20000\\r\\n #finds max degree of graph and stores list of degrees of nodes\\r\\n maxdeg=0\\r\\n degree_dist=[]\\r\\n for i in range(0,n):\\r\\n degree_dist.append(G.degree[i])\\r\\n if G.degree[i]>maxdeg:\\r\\n maxdeg=G.degree[i]\\r\\n j=i\\r\\n #generates data and stores them in lists for varyin M and Nt\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes=[]\\r\\n for i in range(M):\\r\\n Listnodes.append(G.degree(X[i,Nt]))\\r\\n Nt=10000\\r\\n M=20000\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes2=[]\\r\\n for i in range(M):\\r\\n Listnodes2.append(G.degree(X[i,Nt]))\\r\\n Nt=10\\r\\n M=20000\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes3=[]\\r\\n for i in range(M):\\r\\n Listnodes3.append(G.degree(X[i,Nt]))\\r\\n Nt=10000\\r\\n M=200\\r\\n X=rwgraph(G,j,M,Nt)\\r\\n Listnodes4=[]\\r\\n for i in range(M):\\r\\n Listnodes4.append(G.degree(X[i,Nt]))\\r\\n fig, ax1 = plt.subplots(figsize =(14,7))\\r\\n\\r\\n ##### creates histo gram figure with 2 axis####\\r\\n ax1.hist([Listnodes,Listnodes2], bins=maxdeg, label=['Nt=100', 'Nt=10000'],color=['g','r'],alpha=0.6)\\r\\n ax1.set_xlabel('degree of node')\\r\\n ax1.set_ylabel('frequency of final position of random walks')\\r\\n\\r\\n ax1.tick_params(axis='y')\\r\\n ax2 = ax1.twinx() # instantiate a second axes that shares the same x-axis\\r\\n\\r\\n ax2.hist([degree_dist], bins=maxdeg, label=['graph node frequency'],color=['b'],alpha=0.6)\\r\\n ax2.set_ylabel('frequency of node degrees for graph')\\r\\n ax2.tick_params(axis='y')\\r\\n\\r\\n ax1.legend(loc=\\\"center right\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n ax2.legend(loc=\\\"upper right\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title('M=20000, node degree of final position of random walk, for varying amounts of time', y=1.10, fontsize=20)\\r\\n fig.tight_layout() # otherwise the right y-label is slightly clipped\\r\\n plt.grid(b=None)\\r\\n plt.show()\\r\\n\\r\\n #function to generate diction of frequency\\r\\n def CountFrequency(my_list):\\r\\n\\r\\n # Creating an empty dictionary\\r\\n freq = {}\\r\\n for item in my_list:\\r\\n if (item in freq):\\r\\n freq[item] += 1\\r\\n else:\\r\\n freq[item] = 1\\r\\n return freq\\r\\n #converts data to approprate form so it can plotted on scatter plot\\r\\n #frequecy\\r\\n listfreq1=CountFrequency(Listnodes2)\\r\\n listfreq2=CountFrequency(Listnodes3)\\r\\n listfreq3=CountFrequency(Listnodes4)\\r\\n listfreq_deg=CountFrequency(degree_dist)\\r\\n #set up lists\\r\\n z=[]\\r\\n z2=[]\\r\\n z3=[]\\r\\n z_deg=[]\\r\\n z_deg2=[]\\r\\n z_deg3=[]\\r\\n #code to create list of only degrees used in simulations\\r\\n for i in listfreq1:\\r\\n z.append(listfreq1[i]/(listfreq_deg[i]*20000))\\r\\n z_deg.append(i)\\r\\n for i in listfreq2:\\r\\n z2.append(listfreq2[i]/(listfreq_deg[i]*20000))\\r\\n z_deg2.append(i)\\r\\n for i in listfreq3:\\r\\n z3.append(listfreq3[i]/(listfreq_deg[i]*200))\\r\\n z_deg3.append(i)\\r\\n #extpected prob distribution\\r\\n E=G.number_of_edges()\\r\\n z0=[]\\r\\n z_deg0=[]\\r\\n for i in listfreq_deg:\\r\\n z0.append(i/(2*E))\\r\\n z_deg0.append(i)\\r\\n #genrates scatter plot figure\\r\\n plt.figure(figsize=(12, 6))\\r\\n plt.scatter(z_deg, z, label='Nt=10000, M=20000')\\r\\n plt.scatter(z_deg2, z2,label='Nt=10, M=20000')\\r\\n plt.scatter(z_deg3, z3,label='Nt=10, M=200')\\r\\n plt.plot(z_deg0,z0,label=\\\"expected prob dist\\\",alpha=0.5)\\r\\n plt.xlabel('degree of node')\\r\\n plt.ylabel('frequency of final position / M*frequency of degree')\\r\\n plt.legend(loc=\\\"upper left\\\", fontsize=12,fancybox=True, framealpha=1, shadow=True, borderpad=1)\\r\\n plt.title(\\\"Frequency of final positions relative to number of nodes of that degree, for changing times Nt and M.\\\")\\r\\n plt.show()\\r\\n return None #modify as needed\\r\",\n \"def get_number_of_relations(model):\\n if model == None:\\n return 0\\n counter = 0\\n for line in model:\\n if line.find('f(2') >= 0:\\n counter += 1\\n return float(counter)\\n #TODO when multiples of same relation, the result is still 1\",\n \"def graph_diameter(variables, relations):\\n diams = []\\n g = as_networkx_graph(variables, relations)\\n components = (g.subgraph(c).copy() for c in nx.connected_components(g))\\n for c in components:\\n diams.append(nx.diameter(c))\\n\\n return diams\",\n \"def histogram(self, image):\\n\\n response = self._send_request(\\\"histogram\\\", files=dict(image=image))\\n return response[self._layer]['histogram']\",\n \"def ngraphs(self):\\n return len(self.__graph_list)\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def relations(self):\\n\\t\\treturn [(self.factions[k][0], self._faction_affinity.get(k, 50)) for k in self.factions.keys()]\",\n \"def analyze_edges_and_weight(list_of_nodes):\\n edges_info = []\\n for node in list_of_nodes:\\n n_edge_of_node = len(node.neighbors) # Counts the kys in the dictionary 'Node.neighbors'\\n total_weight_of_node = sum(list(map(lambda x: node.neighbors[x], node.neighbors))) # Sums values of the dict\\n node_info = (node.name, n_edge_of_node, total_weight_of_node)\\n edges_info.append(node_info)\\n total_n_edges = sum([tup[1] for tup in edges_info]) # Sum total number of edges\\n total_weight_of_graph = sum([tup[2] for tup in edges_info]) # Sum total weight of edges\\n sorted_info = sorted(edges_info, key=lambda tup: tup[1], reverse=True)\\n return \\\"Total number of edges is {},\\\\nTotal weight of the graph is {}:\\\\nNodes sorted by no. of edges: {}.\\\".format(total_n_edges, total_weight_of_graph, sorted_info)\",\n \"def test_ontology_term_graph_based_information_content(ontology):\\n\\tassert ontology.ic(\\\"TO:0000001\\\", as_weight=False) == 0.000\\n\\tassert ontology.ic(\\\"TO:0000002\\\", as_weight=False) == 0.3690702464285426\\n\\tassert ontology.ic(\\\"TO:0000003\\\", as_weight=False) == 0.3690702464285426\\n\\tassert ontology.ic(\\\"TO:0000004\\\", as_weight=False) == 1.000\\n\\tassert ontology.ic(\\\"TO:0000005\\\", as_weight=False) == 3.000\\n\\tassert ontology.ic(\\\"TO:0000006\\\", as_weight=False) == 3.000\\n\\tassert ontology.ic(\\\"TO:0000007\\\", as_weight=False) == 0.500\\n\\tassert ontology.ic(\\\"TO:0000008\\\", as_weight=False) == 1.3690702464285427\\n\\tassert ontology.ic(\\\"TO:0000009\\\", as_weight=False) == 3.000\",\n \"def format_out_relations(relations, out_):\\n\\n if out_ == 'sparse':\\n relations_o = relations\\n elif out_ == 'network':\\n relations_o = nx.from_scipy_sparse_matrix(relations)\\n elif out_ == 'sp_relations':\\n relations_o = RegionDistances(relations)\\n elif out_ == 'list':\\n relations_o = []\\n for i in range(relations.shape[0]):\\n relations_o.append(list(relations.getrow(i).nonzero()[0]))\\n return relations_o\",\n \"def _get_graph_based_ic_dictionary(self):\\n\\n\\t\\t# TODO find the literature reference or presentation where this equation is from instead of just the presentation.\\n\\n\\t\\t#ic_dict = {}\\n\\t\\t#num_terms_in_ontology = len(self)\\n\\t\\t#for term in self.terms():\\n\\t\\t#\\tdepth = self._depth_dict[term.id]\\n\\t\\t#\\tnum_descendants = len(list(term.subclasses(with_self=False)))\\n\\t\\t#\\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\\n\\t\\t#\\tic_dict[term.id] = ic_value\\n\\t\\t#return(ic_dict)\\n\\n\\n\\t\\t# Getting the information content of each term in the ontology based on graph structure.\\n\\t\\tic_dict = {}\\n\\t\\tnum_terms_in_ontology = len(self)\\n\\t\\tfor term in self.terms():\\n\\t\\t\\tdepth = self._depth_dict[term.id]\\n\\t\\t\\tnum_descendants = len(list(term.subclasses(with_self=False)))\\n\\t\\t\\tic_value = float(depth)*(1-(math.log(num_descendants+1)/math.log(num_terms_in_ontology)))\\n\\t\\t\\tic_dict[term.id] = ic_value\\n\\n\\n\\t\\t# Converting to weights based on information content rather than raw value.\\n\\t\\tic_dict_as_weights = {}\\n\\t\\tic_values = ic_dict.values()\\n\\t\\tmin_ic = min(ic_values)\\n\\t\\tmax_ic = max(ic_values)\\n\\t\\tnew_max = 1.00\\n\\t\\tnew_min = 0.00\\n\\t\\tfor k,v in ic_dict.items():\\n\\t\\t\\told_range = max_ic-min_ic\\n\\t\\t\\tnew_range = new_max-new_min\\n\\t\\t\\tnew_value = (((v - min_ic) * new_range) / old_range) + new_min\\n\\t\\t\\tic_dict_as_weights[k] = new_value\\n\\n\\t\\treturn(ic_dict, ic_dict_as_weights)\",\n \"def edges(self, irc, msg, args, channel):\\n pie = self.instances[irc.network]\\n irc.reply([str(x) for x in pie.graphs[channel].edges.values()])\",\n \"def showOrHideHistogramControls(graphType:int):\\n\\n\\tif GRAPHTYPE_CHOICES[graphType] == 'Histogram':\\n\\t\\treturn {'display': 'block'}\\n\\treturn {'display': 'none'}\",\n \"def iter_stats_graph(graph: tfgnn.GraphTensor) -> Iterator[Tuple[str,\\n tfgnn.Field]]:\\n\\n for set_type, set_name, set_obj in tfgnn.iter_sets(graph):\\n if set_type != tfgnn.CONTEXT:\\n # Output a feature for the size of the set.\\n key = f\\\"{set_type}/{set_name}/{tfgnn.SIZE_NAME}\\\"\\n yield key, set_obj.sizes\\n\\n # Output the values for each feature.\\n for feature_name, tensor in set_obj.features.items():\\n if tensor.dtype == tf.string:\\n continue\\n key = f\\\"{set_type}/{set_name}/{feature_name}\\\"\\n yield key, tensor\",\n \"def as_networkx_graph(variables, relations):\\n graph = nx.Graph()\\n\\n # One node for each variables\\n graph.add_nodes_from([v.name for v in variables])\\n\\n for r in relations:\\n for p in all_pairs([e.name for e in r.dimensions]):\\n graph.add_edge(*p)\\n return graph\",\n \"def database_statistics(database):\\n\\tglobal_node_counter = 0\\n\\tglobal_edge_counter = 0\\n\\tn_graphs = 0\\n\\tfor i, g in enumerate(database):\\n\\t\\tfor n in g.nodes:\\n\\t\\t\\tglobal_node_counter += 1\\n\\t\\t\\tfor e in n.edges:\\n\\t\\t\\t\\tglobal_edge_counter += 1\\n\\t\\tn_graphs += 1\\n\\tavg_node = float(global_node_counter) / n_graphs\\n\\tavg_edge = float(global_edge_counter) / n_graphs\\n\\treturn avg_node, avg_edge\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7243773","0.5846342","0.5788476","0.5771844","0.5683003","0.55974525","0.5592673","0.55913526","0.55775154","0.5538538","0.55222","0.55188054","0.53761876","0.53658545","0.5363041","0.5343787","0.529524","0.52806026","0.5279505","0.5273678","0.5265037","0.52416044","0.52044827","0.5204362","0.51930565","0.5157562","0.51557356","0.5137359","0.5124456","0.5122751","0.51210785","0.51009446","0.50991815","0.50895596","0.5082961","0.50817585","0.50812185","0.5065718","0.5062197","0.50599295","0.5054562","0.50456244","0.5041484","0.5030044","0.5015627","0.5011934","0.5010203","0.5006537","0.49879134","0.49824613","0.49672568","0.4963879","0.49581176","0.49559557","0.49557012","0.49455863","0.4937018","0.4920753","0.49128762","0.49037462","0.48979282","0.4897288","0.4889503","0.4878015","0.48726273","0.4871132","0.48709136","0.48630783","0.48617902","0.4853769","0.48481396","0.48452908","0.484317","0.48417613","0.48406586","0.4836043","0.4826448","0.48219696","0.4819983","0.480734","0.48070255","0.47987282","0.47897115","0.47892535","0.4779391","0.47762153","0.47733763","0.47724777","0.47680596","0.4764131","0.47615227","0.47585028","0.47529173","0.475183","0.4750254","0.47487843","0.47485253","0.4745911","0.4741863","0.47412428"],"string":"[\n \"0.7243773\",\n \"0.5846342\",\n \"0.5788476\",\n \"0.5771844\",\n \"0.5683003\",\n \"0.55974525\",\n \"0.5592673\",\n \"0.55913526\",\n \"0.55775154\",\n \"0.5538538\",\n \"0.55222\",\n \"0.55188054\",\n \"0.53761876\",\n \"0.53658545\",\n \"0.5363041\",\n \"0.5343787\",\n \"0.529524\",\n \"0.52806026\",\n \"0.5279505\",\n \"0.5273678\",\n \"0.5265037\",\n \"0.52416044\",\n \"0.52044827\",\n \"0.5204362\",\n \"0.51930565\",\n \"0.5157562\",\n \"0.51557356\",\n \"0.5137359\",\n \"0.5124456\",\n \"0.5122751\",\n \"0.51210785\",\n \"0.51009446\",\n \"0.50991815\",\n \"0.50895596\",\n \"0.5082961\",\n \"0.50817585\",\n \"0.50812185\",\n \"0.5065718\",\n \"0.5062197\",\n \"0.50599295\",\n \"0.5054562\",\n \"0.50456244\",\n \"0.5041484\",\n \"0.5030044\",\n \"0.5015627\",\n \"0.5011934\",\n \"0.5010203\",\n \"0.5006537\",\n \"0.49879134\",\n \"0.49824613\",\n \"0.49672568\",\n \"0.4963879\",\n \"0.49581176\",\n \"0.49559557\",\n \"0.49557012\",\n \"0.49455863\",\n \"0.4937018\",\n \"0.4920753\",\n \"0.49128762\",\n \"0.49037462\",\n \"0.48979282\",\n \"0.4897288\",\n \"0.4889503\",\n \"0.4878015\",\n \"0.48726273\",\n \"0.4871132\",\n \"0.48709136\",\n \"0.48630783\",\n \"0.48617902\",\n \"0.4853769\",\n \"0.48481396\",\n \"0.48452908\",\n \"0.484317\",\n \"0.48417613\",\n \"0.48406586\",\n \"0.4836043\",\n \"0.4826448\",\n \"0.48219696\",\n \"0.4819983\",\n \"0.480734\",\n \"0.48070255\",\n \"0.47987282\",\n \"0.47897115\",\n \"0.47892535\",\n \"0.4779391\",\n \"0.47762153\",\n \"0.47733763\",\n \"0.47724777\",\n \"0.47680596\",\n \"0.4764131\",\n \"0.47615227\",\n \"0.47585028\",\n \"0.47529173\",\n \"0.475183\",\n \"0.4750254\",\n \"0.47487843\",\n \"0.47485253\",\n \"0.4745911\",\n \"0.4741863\",\n \"0.47412428\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6904264"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20158,"cells":{"query":{"kind":"string","value":"Iterates over the annotation keys"},"document":{"kind":"string","value":"def _annotation_iter_helper(graph):\n return (\n key\n for _, _, data in graph.edges(data=True)\n if ANNOTATIONS in data\n for key in data[ANNOTATIONS]\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iterkeys(self):","def iterkeys(self):","def iter_keypoints_labels(self):\n return iter(self.schema)","def _key_index_iter(self: Any) -> Iterator[Tuple[str, Any]]:\n for k, v in vars(self).items():\n yield k, v","def iterate_keys(\n self,\n keys: istr = None,\n terms: istr = None,\n prefixes: istr = None,\n labels: istr = None,\n ) -> Iterable[str]:","def keysAll():","def ikeys(self, prefix=''):","def iterkeys(self, *args, **kwargs):\n self.__iter__(*args, **kwargs)","def items(self):\n for k, v in self._pairs():\n yield k, util.annotate(v)","async def keys(self) -> Iterable[str]:","def __iter__(self) -> Generator:\n for k in self.raw.keys():\n yield k","def keys():","def _map___iter__(self):\n return self.iterkeys()","def __iter__(self, *args, **kwargs):\n for key in self.keys(*args, **kwargs):\n yield key","def __iter__(self):\n return iterkeys(self._ngrams)","def _yamlAttributeKeys(self):\n raise NotImplementedError","def iterkeys(d):\r\n return iter(getattr(d, _iterkeys)())","def AllKeys(self) -> _n_0_t_1[str]:","def iterkeys(self):\n return self.__iter__()","def key_iterator(self):\n return _osgAnimation.mapVertexInfluence_key_iterator(self)","def iterkeys(d):\n return iter(getattr(d, _iterkeys)())","def __iter__(self):\n key = list(self.keys())[0]\n length = len(self[key])\n for i in range(length):\n res = {}\n for key, feature in self.items():\n res[key] = feature.data[feature.name][i]\n yield res","def key_lookup_batch(self, batchiter):\n pass","def iteritems(self, keyword):","def iterkeys(self):\n return iter(self._sequence)","def __iter__(self):\n\t\treturn self.keys()","def __iter__(self):\n for key in self._ctx:\n yield key","def iterkeyrefs(self):\r\n return self.data.iterkeys()","def iterkeyrefs(self):\r\n return self.data.iterkeys()","def annotations(self) -> Iterator['Annotation']:\n return itertools.chain(self.footnotecitations.all(),\n self.cites.all(),\n self.externallinks.all(),\n self.inlinerequirements.all())","def keys(self):\n for ts in self:\n yield ts","def iterkeys(self):\r\n for wr in self.data.iterkeys():\r\n obj = wr()\r\n if obj is not None:\r\n yield obj","def iterkeys(self):\r\n for wr in self.data.iterkeys():\r\n obj = wr()\r\n if obj is not None:\r\n yield obj","def __iter__ (self):\n return iter (self.containments.keys ())","def __iter__(self):\n for acronym in self.keys:\n yield acronym, self.dict[acronym]","def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\n annotations = []\n for item in self.collector:\n data_file_type = os.path.basename(item).split(\".\")[-1]\n annotations.append(\n load_annotation_file(\n os.path.join(\n self.annotation_folder,\n os.path.basename(item).replace(data_file_type, \"json\"),\n )\n )\n )\n\n return annotations","def __iter__(self):\n\n for each in list(self.keys()):\n yield each","def __iter__(self):\n yield from self._type_keys","def iterkeys(self):\n if PY2:\n return self._tagged.iterkeys()\n else:\n return self._tagged.keys()","def __iter__(self) -> (str, np.ndarray):\n for k, v in self.fields.items():\n yield k, v","def keys(self):\n raise NotImplementedError","def __iter__(self):\n return iter(self.keys())","def iterate_types(self) -> Iterator[FakeAnnotation]:\n yield from self.type_annotation.iterate_types()","def __iter__(self):\n return self.keys()","def __iter__(self) -> Iterator[str]:\n return iter(self._keys)","def iteritems(self):","def keys(self):\n return list(s.name.lower() for s in self.attributes)","def _dict_keys(typingctx, d):\n resty = types.DictKeysIterableType(d)\n sig = resty(d)\n codegen = _iterator_codegen(resty)\n return sig, codegen","def Keys(self) -> _n_1_t_4:","def _validate_annotations(self):\n for i, (k, v) in enumerate(self._annotations_dict.items()):\n for index, annotation in enumerate(v):\n startOffset = int(annotation['startOffset'])\n endOffset = int(annotation['endOffset'])\n tweet = self._tweets_dict[k]\n annotatedText = annotation['annotatedText']\n\n realOffset = tweet.find(annotatedText)\n if realOffset != startOffset:\n #print(\"Fixing startOffset for {}. (annotated at position {}, but should be at {})\".format(k, startOffset, realOffset))\n\n diff = realOffset - startOffset\n annotation['startOffset'] = \"{}\".format(startOffset+diff)\n annotation['endOffset'] = \"{}\".format(endOffset+diff)","def key_iterator(self):\n return _osgAnimation.BoneMap_key_iterator(self)","def iteritems(self):\n for key in self:\n yield (key, self[key])","def keys(targets):","def iterkeys(self):\r\n return self.data.iterkeys()","def __iter__(self):\n return self.ordered_keys.__iter__()","def iterentries(self):\n for key in self.iterkeys():\n yield self.get(key)","def iterkeys(d, **kw):\r\n return iter(getattr(d, _iterkeys)(**kw))","def iterkeys(d, **kw):\r\n return iter(getattr(d, _iterkeys)(**kw))","def get_annotations(graph):\n return set(_annotation_iter_helper(graph))","def __iter__(self):\n for bucket in self._table:\n if bucket is not None:\n for key in bucket:\n yield key","def keys(self):\n\t\treturn iter(Point(x, y) for y, x in itertools.product(range(self.dims.height), range(self.dims.width)))","def iteritems(self):\n for key in self:\n yield key, self[key]","def iterkeys(self):\n\n for bucket in self.buckets.itervalues():\n for key in bucket.iterkeys():\n yield key","def get_alignable_annotations(self, root):\n\n aas = root.findall(\".//ALIGNABLE_ANNOTATION\")\n return {aa.attrib[\"ANNOTATION_ID\"]: aa for aa in aas}","def __iter__(self):\n for keyword in self.meta.findall(CN('meta:keyword')):\n yield keyword.text","def keyValues(self): # real signature unknown; restored from __doc__\n return []","def keys(self):\n return iter(k for k, _ in self._pairs())","def iterkeys(self):\n return iter(kvp.key for kvp in self.keyvaluepair_set.all())","def get_encoded_labels(self, keys):\n to_return = []\n for key in keys:\n to_return.append(self.attr_map[key])\n # need to transform to N arrays, as KERAS requires all labels for one output/attribute\n # in single array, so for 5 attributes and bulk 1024, it will be 5 arrays of length\n # 10240\n return [np.array(tmp_arr) for tmp_arr in zip(*to_return)]","def _merge_field_keys(annotation_fields, defaults_dict):\n anno_keys = list(annotation_fields.keys())\n dict_keys = defaults_dict.keys()\n if not dict_keys:\n return anno_keys\n # Fields with default values must follow those without defaults, so find the first key with\n # annotation that appear in the class dict, the previous keys must be in the front of the key list\n all_keys = []\n # Use this flag to guarantee all fields with defaults following fields without defaults.\n seen_default = False\n for key in anno_keys:\n if key in dict_keys:\n seen_default = True\n else:\n if seen_default:\n raise UserErrorException(f\"Non-default argument {key!r} follows default argument.\")\n all_keys.append(key)\n # Append all keys in dict\n all_keys.extend(dict_keys)\n return all_keys","def _get_annotations(self, node, offset_mngr):\n for anno in self._iterfind(node, 'annotation'):\n offsets = list(self._get_offsets(anno, offset_mngr))\n yield self._entity(anno, offsets)","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def _keys(self):\n for name in listdir(abspath(self._path)):\n key, ext = splitext(name)\n if ext == \".pkl\":\n yield key","def keys_for_tags(self):\r\n\r\n for counter, t_temp in enumerate(sorted(self.get_tags())):\r\n display.noteprint((labels.TAGS[3:]+POUND+BLANK+str(counter+1)\r\n +BLANK+COLON+BLANK+t_temp,\r\n formkeys(self.get_keys_for_tag(t_temp))))","def iterkeyrefs(self):\n for key in self.iterkeys():\n yield ref(key)","def _get_keys(self, ckey):\n if self.has_key(ckey):\n doc = self[ckey]\n else:\n doc = [o for o in self.get_values(ckey)]\n if isinstance(doc, dict):\n for key in doc.keys():\n if ckey.rfind('%s.' % key) == -1:\n combo = '%s.%s' % (ckey, key)\n yield combo\n vals = [v for v in self.get_values(combo)]\n for kkk in helper_loop(combo, vals):\n yield kkk\n else:\n yield ckey\n elif isinstance(doc, list):\n for item in doc:\n if isinstance(item, dict):\n for key in item.keys():\n if ckey.rfind('%s.' % key) == -1:\n combo = '%s.%s' % (ckey, key)\n yield combo\n vals = [v for v in self.get_values(combo)]\n for kkk in helper_loop(combo, vals):\n yield kkk\n elif isinstance(item, list):\n for elem in item:\n if isinstance(elem, dict):\n for kkk in elem.keys():\n yield '%s.%s' % (ckey, kkk)\n else:\n yield ckey\n else: # basic type, so we reach the end\n yield ckey\n else: # basic type, so we reach the end\n yield ckey","def __iter__(self):\n for mapping in self._mappings.values():\n yield mapping","def keys(self) -> List:\n pass","def all(self):\r\n return self.attr_dict.keys()","def keys(self) -> Sequence[str]:\n raise NotImplementedError","def secondary_keys_dicts(self):","def keys(self):\n return [a.name for a in self.__attrs_attrs__]","def __iter__(self):\n\n # For each key in set of keys\n for key in self.keys_set:\n\n # Yield that key and associated value\n yield key, self.__getitem__(key)","def itermappings(self):\r\n return self.by_target.iteritems()","def keys(self):\n return","def getNameIter(self):\n return iter(self._nameDetectorDict.keys())","def keys(self):\n return iter(self._noise_objs.keys())","def __iter__(self):\n\n return iter([key for key in self._data.keys()])","def __iter__(self):\n prefix = len(META_NS) + 2\n for key, value in self.stats.items():\n yield (key[prefix:-6], int(value))","def itermappings(self):\n return six.iteritems(self.by_target)","def get_annotations(data_folder):\n annotations_files = os.listdir('data_annotations')\n\n annotations = {}\n for file_name in annotations_files:\n annotation = json.load(\n open(f'{data_folder}/annotations/{file_name}', 'r')\n )\n key = int(annotation['entity_id'])\n annotations[key] = annotation['value']['value']\n\n return annotations","def __iter__(self):\n return iter(self._key_order)","def values(self):\n return iter(util.annotate(v) for _, v in self._pairs())","def itervalues(self):\n for key in self:\n yield self[key]","def labels_fixed(annotation, label_keys):\n labels = dict(annotation.labels.order_by('key').values_list('key', 'title'))\n return [labels.get(key, '') for key in label_keys]","def keys(self):\n return _osgAnimation.mapVertexInfluence_keys(self)","def keys(self):\r\n return [k for k in self]","def annotations(self):\n return self._annotations","def iter_keys_as_str(self, key):\n for i in range(winreg.QueryInfoKey(key)[0]):\n yield winreg.EnumKey(key, i)"],"string":"[\n \"def iterkeys(self):\",\n \"def iterkeys(self):\",\n \"def iter_keypoints_labels(self):\\n return iter(self.schema)\",\n \"def _key_index_iter(self: Any) -> Iterator[Tuple[str, Any]]:\\n for k, v in vars(self).items():\\n yield k, v\",\n \"def iterate_keys(\\n self,\\n keys: istr = None,\\n terms: istr = None,\\n prefixes: istr = None,\\n labels: istr = None,\\n ) -> Iterable[str]:\",\n \"def keysAll():\",\n \"def ikeys(self, prefix=''):\",\n \"def iterkeys(self, *args, **kwargs):\\n self.__iter__(*args, **kwargs)\",\n \"def items(self):\\n for k, v in self._pairs():\\n yield k, util.annotate(v)\",\n \"async def keys(self) -> Iterable[str]:\",\n \"def __iter__(self) -> Generator:\\n for k in self.raw.keys():\\n yield k\",\n \"def keys():\",\n \"def _map___iter__(self):\\n return self.iterkeys()\",\n \"def __iter__(self, *args, **kwargs):\\n for key in self.keys(*args, **kwargs):\\n yield key\",\n \"def __iter__(self):\\n return iterkeys(self._ngrams)\",\n \"def _yamlAttributeKeys(self):\\n raise NotImplementedError\",\n \"def iterkeys(d):\\r\\n return iter(getattr(d, _iterkeys)())\",\n \"def AllKeys(self) -> _n_0_t_1[str]:\",\n \"def iterkeys(self):\\n return self.__iter__()\",\n \"def key_iterator(self):\\n return _osgAnimation.mapVertexInfluence_key_iterator(self)\",\n \"def iterkeys(d):\\n return iter(getattr(d, _iterkeys)())\",\n \"def __iter__(self):\\n key = list(self.keys())[0]\\n length = len(self[key])\\n for i in range(length):\\n res = {}\\n for key, feature in self.items():\\n res[key] = feature.data[feature.name][i]\\n yield res\",\n \"def key_lookup_batch(self, batchiter):\\n pass\",\n \"def iteritems(self, keyword):\",\n \"def iterkeys(self):\\n return iter(self._sequence)\",\n \"def __iter__(self):\\n\\t\\treturn self.keys()\",\n \"def __iter__(self):\\n for key in self._ctx:\\n yield key\",\n \"def iterkeyrefs(self):\\r\\n return self.data.iterkeys()\",\n \"def iterkeyrefs(self):\\r\\n return self.data.iterkeys()\",\n \"def annotations(self) -> Iterator['Annotation']:\\n return itertools.chain(self.footnotecitations.all(),\\n self.cites.all(),\\n self.externallinks.all(),\\n self.inlinerequirements.all())\",\n \"def keys(self):\\n for ts in self:\\n yield ts\",\n \"def iterkeys(self):\\r\\n for wr in self.data.iterkeys():\\r\\n obj = wr()\\r\\n if obj is not None:\\r\\n yield obj\",\n \"def iterkeys(self):\\r\\n for wr in self.data.iterkeys():\\r\\n obj = wr()\\r\\n if obj is not None:\\r\\n yield obj\",\n \"def __iter__ (self):\\n return iter (self.containments.keys ())\",\n \"def __iter__(self):\\n for acronym in self.keys:\\n yield acronym, self.dict[acronym]\",\n \"def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\\n annotations = []\\n for item in self.collector:\\n data_file_type = os.path.basename(item).split(\\\".\\\")[-1]\\n annotations.append(\\n load_annotation_file(\\n os.path.join(\\n self.annotation_folder,\\n os.path.basename(item).replace(data_file_type, \\\"json\\\"),\\n )\\n )\\n )\\n\\n return annotations\",\n \"def __iter__(self):\\n\\n for each in list(self.keys()):\\n yield each\",\n \"def __iter__(self):\\n yield from self._type_keys\",\n \"def iterkeys(self):\\n if PY2:\\n return self._tagged.iterkeys()\\n else:\\n return self._tagged.keys()\",\n \"def __iter__(self) -> (str, np.ndarray):\\n for k, v in self.fields.items():\\n yield k, v\",\n \"def keys(self):\\n raise NotImplementedError\",\n \"def __iter__(self):\\n return iter(self.keys())\",\n \"def iterate_types(self) -> Iterator[FakeAnnotation]:\\n yield from self.type_annotation.iterate_types()\",\n \"def __iter__(self):\\n return self.keys()\",\n \"def __iter__(self) -> Iterator[str]:\\n return iter(self._keys)\",\n \"def iteritems(self):\",\n \"def keys(self):\\n return list(s.name.lower() for s in self.attributes)\",\n \"def _dict_keys(typingctx, d):\\n resty = types.DictKeysIterableType(d)\\n sig = resty(d)\\n codegen = _iterator_codegen(resty)\\n return sig, codegen\",\n \"def Keys(self) -> _n_1_t_4:\",\n \"def _validate_annotations(self):\\n for i, (k, v) in enumerate(self._annotations_dict.items()):\\n for index, annotation in enumerate(v):\\n startOffset = int(annotation['startOffset'])\\n endOffset = int(annotation['endOffset'])\\n tweet = self._tweets_dict[k]\\n annotatedText = annotation['annotatedText']\\n\\n realOffset = tweet.find(annotatedText)\\n if realOffset != startOffset:\\n #print(\\\"Fixing startOffset for {}. (annotated at position {}, but should be at {})\\\".format(k, startOffset, realOffset))\\n\\n diff = realOffset - startOffset\\n annotation['startOffset'] = \\\"{}\\\".format(startOffset+diff)\\n annotation['endOffset'] = \\\"{}\\\".format(endOffset+diff)\",\n \"def key_iterator(self):\\n return _osgAnimation.BoneMap_key_iterator(self)\",\n \"def iteritems(self):\\n for key in self:\\n yield (key, self[key])\",\n \"def keys(targets):\",\n \"def iterkeys(self):\\r\\n return self.data.iterkeys()\",\n \"def __iter__(self):\\n return self.ordered_keys.__iter__()\",\n \"def iterentries(self):\\n for key in self.iterkeys():\\n yield self.get(key)\",\n \"def iterkeys(d, **kw):\\r\\n return iter(getattr(d, _iterkeys)(**kw))\",\n \"def iterkeys(d, **kw):\\r\\n return iter(getattr(d, _iterkeys)(**kw))\",\n \"def get_annotations(graph):\\n return set(_annotation_iter_helper(graph))\",\n \"def __iter__(self):\\n for bucket in self._table:\\n if bucket is not None:\\n for key in bucket:\\n yield key\",\n \"def keys(self):\\n\\t\\treturn iter(Point(x, y) for y, x in itertools.product(range(self.dims.height), range(self.dims.width)))\",\n \"def iteritems(self):\\n for key in self:\\n yield key, self[key]\",\n \"def iterkeys(self):\\n\\n for bucket in self.buckets.itervalues():\\n for key in bucket.iterkeys():\\n yield key\",\n \"def get_alignable_annotations(self, root):\\n\\n aas = root.findall(\\\".//ALIGNABLE_ANNOTATION\\\")\\n return {aa.attrib[\\\"ANNOTATION_ID\\\"]: aa for aa in aas}\",\n \"def __iter__(self):\\n for keyword in self.meta.findall(CN('meta:keyword')):\\n yield keyword.text\",\n \"def keyValues(self): # real signature unknown; restored from __doc__\\n return []\",\n \"def keys(self):\\n return iter(k for k, _ in self._pairs())\",\n \"def iterkeys(self):\\n return iter(kvp.key for kvp in self.keyvaluepair_set.all())\",\n \"def get_encoded_labels(self, keys):\\n to_return = []\\n for key in keys:\\n to_return.append(self.attr_map[key])\\n # need to transform to N arrays, as KERAS requires all labels for one output/attribute\\n # in single array, so for 5 attributes and bulk 1024, it will be 5 arrays of length\\n # 10240\\n return [np.array(tmp_arr) for tmp_arr in zip(*to_return)]\",\n \"def _merge_field_keys(annotation_fields, defaults_dict):\\n anno_keys = list(annotation_fields.keys())\\n dict_keys = defaults_dict.keys()\\n if not dict_keys:\\n return anno_keys\\n # Fields with default values must follow those without defaults, so find the first key with\\n # annotation that appear in the class dict, the previous keys must be in the front of the key list\\n all_keys = []\\n # Use this flag to guarantee all fields with defaults following fields without defaults.\\n seen_default = False\\n for key in anno_keys:\\n if key in dict_keys:\\n seen_default = True\\n else:\\n if seen_default:\\n raise UserErrorException(f\\\"Non-default argument {key!r} follows default argument.\\\")\\n all_keys.append(key)\\n # Append all keys in dict\\n all_keys.extend(dict_keys)\\n return all_keys\",\n \"def _get_annotations(self, node, offset_mngr):\\n for anno in self._iterfind(node, 'annotation'):\\n offsets = list(self._get_offsets(anno, offset_mngr))\\n yield self._entity(anno, offsets)\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def _keys(self):\\n for name in listdir(abspath(self._path)):\\n key, ext = splitext(name)\\n if ext == \\\".pkl\\\":\\n yield key\",\n \"def keys_for_tags(self):\\r\\n\\r\\n for counter, t_temp in enumerate(sorted(self.get_tags())):\\r\\n display.noteprint((labels.TAGS[3:]+POUND+BLANK+str(counter+1)\\r\\n +BLANK+COLON+BLANK+t_temp,\\r\\n formkeys(self.get_keys_for_tag(t_temp))))\",\n \"def iterkeyrefs(self):\\n for key in self.iterkeys():\\n yield ref(key)\",\n \"def _get_keys(self, ckey):\\n if self.has_key(ckey):\\n doc = self[ckey]\\n else:\\n doc = [o for o in self.get_values(ckey)]\\n if isinstance(doc, dict):\\n for key in doc.keys():\\n if ckey.rfind('%s.' % key) == -1:\\n combo = '%s.%s' % (ckey, key)\\n yield combo\\n vals = [v for v in self.get_values(combo)]\\n for kkk in helper_loop(combo, vals):\\n yield kkk\\n else:\\n yield ckey\\n elif isinstance(doc, list):\\n for item in doc:\\n if isinstance(item, dict):\\n for key in item.keys():\\n if ckey.rfind('%s.' % key) == -1:\\n combo = '%s.%s' % (ckey, key)\\n yield combo\\n vals = [v for v in self.get_values(combo)]\\n for kkk in helper_loop(combo, vals):\\n yield kkk\\n elif isinstance(item, list):\\n for elem in item:\\n if isinstance(elem, dict):\\n for kkk in elem.keys():\\n yield '%s.%s' % (ckey, kkk)\\n else:\\n yield ckey\\n else: # basic type, so we reach the end\\n yield ckey\\n else: # basic type, so we reach the end\\n yield ckey\",\n \"def __iter__(self):\\n for mapping in self._mappings.values():\\n yield mapping\",\n \"def keys(self) -> List:\\n pass\",\n \"def all(self):\\r\\n return self.attr_dict.keys()\",\n \"def keys(self) -> Sequence[str]:\\n raise NotImplementedError\",\n \"def secondary_keys_dicts(self):\",\n \"def keys(self):\\n return [a.name for a in self.__attrs_attrs__]\",\n \"def __iter__(self):\\n\\n # For each key in set of keys\\n for key in self.keys_set:\\n\\n # Yield that key and associated value\\n yield key, self.__getitem__(key)\",\n \"def itermappings(self):\\r\\n return self.by_target.iteritems()\",\n \"def keys(self):\\n return\",\n \"def getNameIter(self):\\n return iter(self._nameDetectorDict.keys())\",\n \"def keys(self):\\n return iter(self._noise_objs.keys())\",\n \"def __iter__(self):\\n\\n return iter([key for key in self._data.keys()])\",\n \"def __iter__(self):\\n prefix = len(META_NS) + 2\\n for key, value in self.stats.items():\\n yield (key[prefix:-6], int(value))\",\n \"def itermappings(self):\\n return six.iteritems(self.by_target)\",\n \"def get_annotations(data_folder):\\n annotations_files = os.listdir('data_annotations')\\n\\n annotations = {}\\n for file_name in annotations_files:\\n annotation = json.load(\\n open(f'{data_folder}/annotations/{file_name}', 'r')\\n )\\n key = int(annotation['entity_id'])\\n annotations[key] = annotation['value']['value']\\n\\n return annotations\",\n \"def __iter__(self):\\n return iter(self._key_order)\",\n \"def values(self):\\n return iter(util.annotate(v) for _, v in self._pairs())\",\n \"def itervalues(self):\\n for key in self:\\n yield self[key]\",\n \"def labels_fixed(annotation, label_keys):\\n labels = dict(annotation.labels.order_by('key').values_list('key', 'title'))\\n return [labels.get(key, '') for key in label_keys]\",\n \"def keys(self):\\n return _osgAnimation.mapVertexInfluence_keys(self)\",\n \"def keys(self):\\r\\n return [k for k in self]\",\n \"def annotations(self):\\n return self._annotations\",\n \"def iter_keys_as_str(self, key):\\n for i in range(winreg.QueryInfoKey(key)[0]):\\n yield winreg.EnumKey(key, i)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6948478","0.6948478","0.6455085","0.6263266","0.6235896","0.6149486","0.6079361","0.59984857","0.5966069","0.5909791","0.5881101","0.585842","0.5820509","0.58111554","0.5806297","0.58045775","0.5788105","0.5782316","0.5751768","0.5739767","0.5723479","0.57064","0.5704723","0.5702102","0.568477","0.5643574","0.5637097","0.56317806","0.56317806","0.56308556","0.561181","0.55894935","0.55894935","0.55860585","0.5583652","0.55810094","0.55743283","0.5571482","0.5571094","0.55694556","0.55601215","0.5553726","0.55535746","0.5538892","0.5524533","0.5505784","0.54967445","0.5481496","0.5475725","0.54697615","0.5462287","0.5461388","0.5444173","0.544417","0.5435655","0.5421974","0.5419368","0.5419368","0.5410417","0.54055995","0.5404575","0.53967416","0.53780544","0.53769433","0.53728396","0.53715414","0.53497505","0.53378785","0.5335974","0.533456","0.53336096","0.5333135","0.5333135","0.53182566","0.53167015","0.5315919","0.531471","0.5314181","0.5310569","0.531008","0.52953273","0.529418","0.52887076","0.5284315","0.5271098","0.5269238","0.52397996","0.52387","0.5236875","0.52305263","0.5227179","0.52206254","0.52126324","0.5199846","0.519529","0.5193208","0.5186269","0.51826465","0.51804465","0.51788527"],"string":"[\n \"0.6948478\",\n \"0.6948478\",\n \"0.6455085\",\n \"0.6263266\",\n \"0.6235896\",\n \"0.6149486\",\n \"0.6079361\",\n \"0.59984857\",\n \"0.5966069\",\n \"0.5909791\",\n \"0.5881101\",\n \"0.585842\",\n \"0.5820509\",\n \"0.58111554\",\n \"0.5806297\",\n \"0.58045775\",\n \"0.5788105\",\n \"0.5782316\",\n \"0.5751768\",\n \"0.5739767\",\n \"0.5723479\",\n \"0.57064\",\n \"0.5704723\",\n \"0.5702102\",\n \"0.568477\",\n \"0.5643574\",\n \"0.5637097\",\n \"0.56317806\",\n \"0.56317806\",\n \"0.56308556\",\n \"0.561181\",\n \"0.55894935\",\n \"0.55894935\",\n \"0.55860585\",\n \"0.5583652\",\n \"0.55810094\",\n \"0.55743283\",\n \"0.5571482\",\n \"0.5571094\",\n \"0.55694556\",\n \"0.55601215\",\n \"0.5553726\",\n \"0.55535746\",\n \"0.5538892\",\n \"0.5524533\",\n \"0.5505784\",\n \"0.54967445\",\n \"0.5481496\",\n \"0.5475725\",\n \"0.54697615\",\n \"0.5462287\",\n \"0.5461388\",\n \"0.5444173\",\n \"0.544417\",\n \"0.5435655\",\n \"0.5421974\",\n \"0.5419368\",\n \"0.5419368\",\n \"0.5410417\",\n \"0.54055995\",\n \"0.5404575\",\n \"0.53967416\",\n \"0.53780544\",\n \"0.53769433\",\n \"0.53728396\",\n \"0.53715414\",\n \"0.53497505\",\n \"0.53378785\",\n \"0.5335974\",\n \"0.533456\",\n \"0.53336096\",\n \"0.5333135\",\n \"0.5333135\",\n \"0.53182566\",\n \"0.53167015\",\n \"0.5315919\",\n \"0.531471\",\n \"0.5314181\",\n \"0.5310569\",\n \"0.531008\",\n \"0.52953273\",\n \"0.529418\",\n \"0.52887076\",\n \"0.5284315\",\n \"0.5271098\",\n \"0.5269238\",\n \"0.52397996\",\n \"0.52387\",\n \"0.5236875\",\n \"0.52305263\",\n \"0.5227179\",\n \"0.52206254\",\n \"0.52126324\",\n \"0.5199846\",\n \"0.519529\",\n \"0.5193208\",\n \"0.5186269\",\n \"0.51826465\",\n \"0.51804465\",\n \"0.51788527\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69208306"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":20159,"cells":{"query":{"kind":"string","value":"Counts how many times each annotation is used in the graph"},"document":{"kind":"string","value":"def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))","def get_annotation_count(self):\n return self._num_annos","def get_no_of_annotations(database, label, train_vids_all):\n count = 0\n for vid in train_vids_all:\n for ann in database[vid]['annotations']:\n if ann['label'] == label:\n count += 1\n return count","def count():","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):\n source_filter = keep_node_permissive if source_filter is None else source_filter\n target_filter = keep_node_permissive if target_filter is None else target_filter\n\n return Counter(\n data[ANNOTATIONS][annotation]\n for u, v, data in graph.edges_iter(data=True)\n if edge_has_annotation(data, annotation) and source_filter(graph, u) and target_filter(graph, v)\n )","def getCounts(self):\n ret = [0]*len(self.numToLabel)\n for block in self.blocks:\n for label in block[1]: ret[label] += 1\n return ret","def mark_as(self, label: str) -> int:\n self.label = label\n return len(self._content) // len(ANNOTATIONS)","def test_total_new_annotations():\n\told_num_anns = len(oset['annotations'])\n\tnew_num_anns = len(nset['annotations'])\n\tnum_NAs_found = 0\n\n\told_anns = oset['annotations']\n\tfor ann in old_anns:\n\t\tann_id = ann['id']\n\t\tcat_id = ann['category_id']\n\t\tcat = old_coco_obj.cats[cat_id]\n\t\tOL = cat['name']\n\t\tfor search_row in map_rows:\n\t\t\tif OL == search_row[0]:\n\t\t\t\trow = search_row \n\t\t\t\tNL = row[2]\n\n\t\t\t\t# now we have the particular row from the CSV whose old category corresponds to this annotation's category\n\t\t\t\tif NL == 'NA':\n\t\t\t\t\tnum_NAs_found += 1\n\n\tassert old_num_anns - num_NAs_found == new_num_anns","def count_nodes(self, term=None, labels: istr = None) -> int:","def resultCounter(detections):\n counter = 0\n for attribute, value in classIterator(detections):\n if 'crease' in attribute:\n counter += len(value)\n return counter","def count_nodes(self, term=None, labels: istr = None):","def count(self):\n\n raise NotImplementedError","def hits(self):\n return sum(self.labels.values())","def getHitCount(self): #$NON-NLS-1$\r","def obstacle_count(self):\n #scan area in front of robot\n self.scan()\n #Figure ot how many obstacles there were\n see_an_object = False\n count = 0","def get_gini(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])","def obstacle_count(self):\n self.wide_scan()\n found_something = False\n counter = 0\n for distance in self.scan:\n if distance and distance < 200 and not found_something:\n found_something = True\n counter += 1\n print(\"Object # %d found, I think\" % counter)\n if distance and distance > 200 and found_something:\n found_something = False\n print(\"\\n----I SEE %d OBJECTS----\\n\" % counter)","def _get_observation_count(self):\n observation_count = 0\n for sequence in self.seq_list:\n observation_count += sequence.shape[0] \n \n return observation_count","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def Count(self) -> int:","def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))","def count_pegs(self):\r\n count = 0\r\n\r\n for i in range(0, len(self.matrix)):\r\n for j in range(0, len(self.matrix[i])):\r\n if self.matrix[i][j] == \"1\":\r\n count += 1\r\n\r\n return count","def num_labels(self) -> int:\n raise NotImplementedError","def gal_count(clusters):\n sum = 0\n for x in clusters:\n sum += x.ngal\n return sum","def count(self):\n\t\treturn len(list(self.nodes))","def node_count(self) -> int:\n return int(self.graph_tuple_stats.node_count or 0)","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def cluster_obs_count(self):\n return(self.merged_data.groupby(\n 'labels').count().transpose().iloc[0, :])","def count_classes(labels):\n class_dict = {}\n for image in labels:\n for row in image:\n for label in row:\n if label not in class_dict:\n class_dict[label] = 1\n else:\n class_dict[label] += 1\n return class_dict","def ir_count(self) -> int:\n return int(self.graph_tuple_stats.ir_count or 0)","def create_count_map(self) -> Dict[int, int]:\n res: Dict[int, int] = {}\n for sequence_data in self.model.values():\n sequence_data: NGramsSequence = cast(NGramsSequence, sequence_data)\n for count in sequence_data.next_count.values():\n count: int = cast(int, count)\n if count not in res:\n res[count] = 0\n res[count] += 1\n self.count_map = res\n logger.success('created count map')\n return res","def count_target(self):\n tally = {}\n for obj in self.target:\n tally[obj] = 0\n\n ind = 0\n for label in self.labelList:\n filename = self.pathLabel + label\n f = open(filename, 'r')\n content = f.read().split('\\n')\n for line in content:\n items = line.split(' ')\n if items[0] in self.target:\n tally[items[0]] += 1\n f.close()\n if ind % 100 == 0:\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\n ind += 1\n \n print('[COUNT] done counting targets in dataset')\n print(tally)","def get_corpus_counts(x,y,label):\n raise NotImplementedError","def count_indications(self) -> int:\n return self._count_model(Indication)","def count(seats: List[str]) -> int:\n # Map dimensions\n m = len(seats)\n n = len(seats[0]) if m else 0\n \n count = 0\n \n # Count locations filled with \"#\"\n for i in range(m):\n for j in range(n):\n if seats[i][j] == \"#\":\n count += 1\n\n return count","def count_unvisited(data):\n count = sum(n.count(\"n\") for n in data)\n return count","def count_labels(labels_path):\n counts = np.zeros(4)\n with open(labels_path, 'r') as f:\n for line in f:\n line = int(line.split()[1]) - 1\n counts[line] += 1\n\n return counts","def __len__(self) -> int:\n return self._num_ann","def num_inducing(self) -> tf.Tensor:\n raise NotImplementedError","def counts(self):\n\n counts = defaultdict(int)\n\n for i, geom in zip(self.tree_ids, self.tree):\n point_int = list(self.sindex.intersection(geom.bounds))\n if point_int:\n counts[i] += len(point_int)\n\n return dict(counts)","def count_tags(tag_events):\n tagged_lines = []\n for tag_event in tag_events:\n for tag in tag_event[1][\"tag\"][\"labels\"]:\n tagged_lines.append(tag)\n tag_counts = Counter(tagged_lines)\n return tag_counts","def gen_img_counts(img_path, model):\n\n img = transform(Image.open(img_path).convert('RGB'))\n print(type(img))\n output = model(img.unsqueeze(0))\n pred_count = int(output.detach().cpu().sum().numpy())\n return pred_count","def getClassCounts(b):\n c = {k:0 for k in labels.keys()}\n for r in b:\n c[r[0]] += 1\n return c","def get_label_counts(dataset_path: str):\n if not dataset_path:\n return None\n td = ImageFolder(root=dataset_path)\n # get label distribution\n label_counts = [0] * len(td.classes)\n for p, l in td.samples:\n label_counts[l] += 1\n return label_counts","def edgecount(self):\n\n raise NotImplementedError","def count(self):\r\n return self.count_helper(self.top_node)","def _collect_counts(self, instance_list):\n \"\"\" Based on each instance, I augment empirical counts for every word and its BIO label in feature_count_table and for every transition from previous label to current label in transition_count_table.\n All \"rare words\" (those words that appear less than 3 times) are replaced by <UNK>.\n I also add label|START counts.\n \"\"\"\n # Build feature_count_table of V x labels and transition_count_table of labels x labels\n for instance in instance_list: # Set of <(w, pos), l>\n index = 0\n for t in instance.data: # Tuple of (w, pos)\n index = instance.data.index(t)\n # print t[0] # word\n # print instance.label[index] # label\n if t in self.V:\n self.feature_count_table[self.V.index(t)][self.labels.index(instance.label[index])] +=1\n else:\n self.feature_count_table[self.V.index('<UNK>')][self.labels.index(instance.label[index])] +=1\n if index > 0:\n self.transition_count_table[self.labels.index(instance.label[index-1])][self.labels.index(instance.label[index])] += 1\n else:\n self.transition_count_table[len(self.labels)][self.labels.index(instance.label[index])] += 1","def count_ones(self):\r\n count = 0\r\n for x in range(self.xspan):\r\n for y in range(self.yspan):\r\n if (self.cells[x][y] == 1):\r\n count = count + 1\r\n return count","def n(self):\n return len(self.marks)","def countAtom (dico_count, PDB_parsed, debug = 0):\n count = 0\n \n for atom in PDB_parsed : \n residue = tool.transformAA(atom[\"resName\"])\n if debug : print residue\n \n if residue in dico_count : \n atom_Name = atom[\"name\"]\n if atom_Name in dico_count[residue] : \n count = count + 1\n return count","def getCount(self):\n return _osgAnimation.Target_getCount(self)","def num_links(self):\n count=0.0\n for cluster in self.clusters:\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\n numberofmembers=self.clusters[cluster].number_of_members\n count+=numberofmembers\n return count","def class_counts(rows):\n counts = {} # a dictionary of label -> count.\n for row in rows:\n # in our dataset format, the label is always the last column\n label = row[-1]\n if label not in counts:\n counts[label] = 0\n counts[label] += 1\n return counts","def class_counts(rows):\n counts = {} # a dictionary of label -> count.\n for row in rows:\n # in our dataset format, the label is always the last column\n label = row[-1]\n if label not in counts:\n counts[label] = 0\n counts[label] += 1\n return counts","def class_counts(rows):\n counts = {} # a dictionary of label -> count.\n for row in rows:\n # in our dataset format, the label is always the last column\n label = row[-1]\n if label not in counts:\n counts[label] = 0\n counts[label] += 1\n return counts","def num_annuli(self) -> int:\n return self._num_ann","def count_points(roi):\r\n # Performing Mean Shift Filtering\r\n shifted = cv2.pyrMeanShiftFiltering(roi, 21, 51)\r\n\r\n # Converting the image to grayscale\r\n gray = cv2.cvtColor(shifted, cv2.COLOR_BGR2GRAY)\r\n\r\n # Thresholding using Binary and OTSU\r\n thrsh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\r\n # Using Watershed Algorithm\r\n D = ndimage.distance_transform_edt(thrsh)\r\n localMax = peak_local_max(D, indices=False, min_distance=1, labels=thrsh)\r\n markers = ndimage.label(localMax)[0]\r\n lbls = watershed(-D, markers, mask=thrsh)\r\n \r\n return lbls, len(np.unique(lbls)) - 1","def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\n return Counter(_naked_names_iter(graph))","def count_gates(qobj, basis, qubits):\n\n #TO DO\n pass","def count_segments(markers) -> int:\n cnt = Counter()\n for row in markers:\n cnt.update(row)\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\n del n_cnt[1]\n del n_cnt[-1]\n return len(n_cnt.keys())","def amine(listAmine, count):\n \n for type in listAmine.keys():\n for nitrogen in listAmine[type]:\n nbNeighbor = numberNeigthbor(nitrogen[\"neighbors\"])\n for neighbor in nitrogen[\"neighbors\"]:\n if not nbNeighbor in count[type].keys():\n count[type][nbNeighbor] = structure.countElements()\n if not nbNeighbor in count[\"GlobalAmine\"].keys():\n count[\"GlobalAmine\"][nbNeighbor] = structure.countElements()\n\n\n if neighbor[\"element\"] in count[type][nbNeighbor].keys():\n count[type][nbNeighbor][neighbor[\"element\"]] = count[type][nbNeighbor][neighbor[\"element\"]] + 1\n count[\"GlobalAmine\"][nbNeighbor][neighbor[\"element\"]] = count[\"GlobalAmine\"][nbNeighbor][neighbor[\"element\"]] + 1\n\n else:\n count[type][nbNeighbor][\"others\"] = count[type][nbNeighbor][\"others\"] + 1\n count[\"GlobalAmine\"][nbNeighbor][\"others\"] = count[\"GlobalAmine\"][nbNeighbor][\"others\"] + 1","def label_stats(label_mapping):\n\tlabels = list(label_mapping.values())\n\n\tfor count, elem in sorted(((labels.count(e), e) for e in set(labels)), reverse=True):\n\t\tprint('%s: \\t\\t %d' % (elem, count))","def numnems(self):\n count = 0\n for o in self._objs.values():\n count += len(o.netifs())\n return count","def count_nodes(self):\n\t\treturn self.__count_nodes(self)","def get_num_of_images(self):","def get_marble_count(self):","def annotations_per_batch(self):\n if self._batch_size is None or self.task in {'objdet', 'sggen'}:\n return self._annotations_per_batch\n annos_per_img = self._annos_per_img[self.dataset]\n if self.task in {'predcls', 'sgcls'}:\n annos_per_img = annos_per_img['pairs']\n elif self.task == 'objcls':\n annos_per_img = annos_per_img['objects']\n elif self.task == 'preddet' and self.filter_multiple_preds:\n annos_per_img = annos_per_img['predicates_filtered']\n elif self.task == 'preddet' and self.filter_duplicate_rels:\n annos_per_img = annos_per_img['duplicates_filtered']\n elif self.task == 'preddet':\n annos_per_img = annos_per_img['relations']\n return annos_per_img * self._batch_size","def get_tag_counts(label_matches):\r\n\ttag_counts = {}\r\n\tfor word_and_tag in label_matches.keys():\r\n\t\tcurrent_count = tag_counts.get(word_and_tag[_TAG], 0)\r\n\t\ttag_counts[word_and_tag[_TAG]] = current_count+1\r\n\treturn tag_counts","def entity_counts(doc):\n \n tags = []\n for token in doc.ents:\n tags.append(token.label_)\n frequency = dict(Counter(tags).most_common())\n\n return frequency","def number_of_running_metrics(self):\n try:\n return len(self.get_classads(\"OSGRSV==\\\"metrics\\\"\"))\n except TypeError:\n self.rsv.log(\"ERROR\", \"Classad parsing failed, unable to count running metrics\")","def count_taxa_tree(tree_nxobj):\n\tnode_count = 0 #number of taxa in the tree\n\tfor node in tree_nxobj.preorder_node_iter():\n\t\tnode_count += 1\n\n\treturn node_count","def count_each_tag(mat):\n cnts = {}\n for vec in mat:\n if vec[-1] not in cnts:\n cnts[vec[-1]] = 0.0\n cnts[vec[-1]] += 1.0\n return cnts","def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )","def get_nodes_pixel_count(self):\n sum_count = self.pixel_count\n for i in range(8):\n node = self.children[i]\n if node:\n sum_count += node.pixel_count\n return sum_count","def _collect_counts(self):\n for t in self.system.keys():\n if t in self.gold:\n self.tp += 1\n else:\n self.fp += 1\n for t in self.gold.keys():\n if t not in self.system:\n self.fn += 1","def __init__(self):\n self.num_counts = {}","def count_labels(self, add_no_ne_label=False):\n return sum([count[1] for count in self.get_label_counts(add_no_ne_label=add_no_ne_label)])","def count(self, trace):\n return len(trace)","def count_elements_in_dataset(dataset):\n return dataset.count()","def count(self):\n # TODO not implemented yet\n return 0","def getCounts():\n for area in AREAS:\n print(area['name'])\n lat = area['lat']\n lng = area['lng']\n count = utils.getExtracted(countCrimes, lat, lng)\n print('count: %s' % count)\n if type(count) is list:\n area['count'] = count[0]\n return AREAS","def number_tokens(dgraph):\n cnt = 0\n for node in dgraph.subgraphs(exclude_root=True):\n node[WORD] = (cnt, node[WORD])\n cnt += 1\n return dgraph","def get_correct_lap_count(self):","def graphToStatCount(node, tag):\n if ':' in tag:\n tag = tag.split(':')[-1]\n s = StatCount(node.tag)\n if node.tag != 'stats':\n s.nodeTranscripts = int(node.attrib['transcripts'])\n s.nodeTranscriptAnnotations = int(node.attrib['transcript_annotations'])\n if node.tag == tag or tag == '*':\n s.tagTranscripts = s.nodeTranscripts\n s.tagTranscriptAnnotations = s.nodeTranscriptAnnotations\n for child in node:\n s.children.append(graphToStatCount(child, tag))\n if node.tag == 'stats':\n for child in s.children:\n s.nodeTranscripts += child.nodeTranscripts\n s.nodeTranscriptAnnotations += child.nodeTranscriptAnnotations\n return s","def num_regions(image_data):\n if len(image_data.shape) > 2:\n image_data = skimage.color.rgb2gray(image_data)\n _, num_labels = ndimage.label(image_data)\n return num_labels","def atom_count(self):\n return len(self.repeated_elements())","def count(self):\n return self.__tree.node_count","def count_passages(self, step, count):\r\n count = int(count)\r\n assert_equals(len(world.css_find('.annotatable-span')), count)\r\n assert_equals(len(world.css_find('.annotatable-span.highlight')), count)\r\n assert_equals(len(world.css_find('.annotatable-span.highlight-yellow')), count)","def num_anchors_per_location(self):\n pass","def label_counts(rows):\n counts = rows.iloc[:, -1].value_counts()\n return counts","def count_params():\n param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\n return param_count","def get_count(self, using):\n obj = self.clone()\n obj.add_annotation(SphinxCount('*'), alias='__count', is_summary=True)\n number = obj.get_aggregation(using, ['__count'])['__count']\n if number is None:\n number = 0\n return number","def generate_feature_counts(traj, mdp):\n #count each time a state was visited \n counts = Counter({feature:0 for feature in mdp.features})\n for state,action in traj:\n counts[mdp.observe_features(state)] += 1\n \n return [counts[feature] for feature in mdp.features]","def sample_count(self):","def _count(self):\n words = [word.lower() for word in self.corpus.words()]\n bigrams_words = bigrams(words)\n for bigram in bigrams_words:\n self._bigrams[bigram] += 1","def test_calculate_count(request):\n print(\"\\n--Starting:\", request.node.name)\n\n net = ModelRoadwayNetwork.read(\n link_file=STPAUL_LINK_FILE,\n node_file=STPAUL_NODE_FILE,\n shape_file=STPAUL_SHAPE_FILE,\n fast=True,\n )\n\n net.add_counts()\n assert \"AADT\" in net.links_df.columns\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\n ## todo write an assert that actually tests something"],"string":"[\n \"def count_annotation_values(graph, annotation):\\n return Counter(iter_annotation_values(graph, annotation))\",\n \"def get_annotation_count(self):\\n return self._num_annos\",\n \"def get_no_of_annotations(database, label, train_vids_all):\\n count = 0\\n for vid in train_vids_all:\\n for ann in database[vid]['annotations']:\\n if ann['label'] == label:\\n count += 1\\n return count\",\n \"def count():\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):\\n source_filter = keep_node_permissive if source_filter is None else source_filter\\n target_filter = keep_node_permissive if target_filter is None else target_filter\\n\\n return Counter(\\n data[ANNOTATIONS][annotation]\\n for u, v, data in graph.edges_iter(data=True)\\n if edge_has_annotation(data, annotation) and source_filter(graph, u) and target_filter(graph, v)\\n )\",\n \"def getCounts(self):\\n ret = [0]*len(self.numToLabel)\\n for block in self.blocks:\\n for label in block[1]: ret[label] += 1\\n return ret\",\n \"def mark_as(self, label: str) -> int:\\n self.label = label\\n return len(self._content) // len(ANNOTATIONS)\",\n \"def test_total_new_annotations():\\n\\told_num_anns = len(oset['annotations'])\\n\\tnew_num_anns = len(nset['annotations'])\\n\\tnum_NAs_found = 0\\n\\n\\told_anns = oset['annotations']\\n\\tfor ann in old_anns:\\n\\t\\tann_id = ann['id']\\n\\t\\tcat_id = ann['category_id']\\n\\t\\tcat = old_coco_obj.cats[cat_id]\\n\\t\\tOL = cat['name']\\n\\t\\tfor search_row in map_rows:\\n\\t\\t\\tif OL == search_row[0]:\\n\\t\\t\\t\\trow = search_row \\n\\t\\t\\t\\tNL = row[2]\\n\\n\\t\\t\\t\\t# now we have the particular row from the CSV whose old category corresponds to this annotation's category\\n\\t\\t\\t\\tif NL == 'NA':\\n\\t\\t\\t\\t\\tnum_NAs_found += 1\\n\\n\\tassert old_num_anns - num_NAs_found == new_num_anns\",\n \"def count_nodes(self, term=None, labels: istr = None) -> int:\",\n \"def resultCounter(detections):\\n counter = 0\\n for attribute, value in classIterator(detections):\\n if 'crease' in attribute:\\n counter += len(value)\\n return counter\",\n \"def count_nodes(self, term=None, labels: istr = None):\",\n \"def count(self):\\n\\n raise NotImplementedError\",\n \"def hits(self):\\n return sum(self.labels.values())\",\n \"def getHitCount(self): #$NON-NLS-1$\\r\",\n \"def obstacle_count(self):\\n #scan area in front of robot\\n self.scan()\\n #Figure ot how many obstacles there were\\n see_an_object = False\\n count = 0\",\n \"def get_gini(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])\",\n \"def obstacle_count(self):\\n self.wide_scan()\\n found_something = False\\n counter = 0\\n for distance in self.scan:\\n if distance and distance < 200 and not found_something:\\n found_something = True\\n counter += 1\\n print(\\\"Object # %d found, I think\\\" % counter)\\n if distance and distance > 200 and found_something:\\n found_something = False\\n print(\\\"\\\\n----I SEE %d OBJECTS----\\\\n\\\" % counter)\",\n \"def _get_observation_count(self):\\n observation_count = 0\\n for sequence in self.seq_list:\\n observation_count += sequence.shape[0] \\n \\n return observation_count\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def Count(self) -> int:\",\n \"def count_pathologies(graph):\\n return Counter(_pathology_iterator(graph))\",\n \"def count_pegs(self):\\r\\n count = 0\\r\\n\\r\\n for i in range(0, len(self.matrix)):\\r\\n for j in range(0, len(self.matrix[i])):\\r\\n if self.matrix[i][j] == \\\"1\\\":\\r\\n count += 1\\r\\n\\r\\n return count\",\n \"def num_labels(self) -> int:\\n raise NotImplementedError\",\n \"def gal_count(clusters):\\n sum = 0\\n for x in clusters:\\n sum += x.ngal\\n return sum\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\",\n \"def node_count(self) -> int:\\n return int(self.graph_tuple_stats.node_count or 0)\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def cluster_obs_count(self):\\n return(self.merged_data.groupby(\\n 'labels').count().transpose().iloc[0, :])\",\n \"def count_classes(labels):\\n class_dict = {}\\n for image in labels:\\n for row in image:\\n for label in row:\\n if label not in class_dict:\\n class_dict[label] = 1\\n else:\\n class_dict[label] += 1\\n return class_dict\",\n \"def ir_count(self) -> int:\\n return int(self.graph_tuple_stats.ir_count or 0)\",\n \"def create_count_map(self) -> Dict[int, int]:\\n res: Dict[int, int] = {}\\n for sequence_data in self.model.values():\\n sequence_data: NGramsSequence = cast(NGramsSequence, sequence_data)\\n for count in sequence_data.next_count.values():\\n count: int = cast(int, count)\\n if count not in res:\\n res[count] = 0\\n res[count] += 1\\n self.count_map = res\\n logger.success('created count map')\\n return res\",\n \"def count_target(self):\\n tally = {}\\n for obj in self.target:\\n tally[obj] = 0\\n\\n ind = 0\\n for label in self.labelList:\\n filename = self.pathLabel + label\\n f = open(filename, 'r')\\n content = f.read().split('\\\\n')\\n for line in content:\\n items = line.split(' ')\\n if items[0] in self.target:\\n tally[items[0]] += 1\\n f.close()\\n if ind % 100 == 0:\\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\\n ind += 1\\n \\n print('[COUNT] done counting targets in dataset')\\n print(tally)\",\n \"def get_corpus_counts(x,y,label):\\n raise NotImplementedError\",\n \"def count_indications(self) -> int:\\n return self._count_model(Indication)\",\n \"def count(seats: List[str]) -> int:\\n # Map dimensions\\n m = len(seats)\\n n = len(seats[0]) if m else 0\\n \\n count = 0\\n \\n # Count locations filled with \\\"#\\\"\\n for i in range(m):\\n for j in range(n):\\n if seats[i][j] == \\\"#\\\":\\n count += 1\\n\\n return count\",\n \"def count_unvisited(data):\\n count = sum(n.count(\\\"n\\\") for n in data)\\n return count\",\n \"def count_labels(labels_path):\\n counts = np.zeros(4)\\n with open(labels_path, 'r') as f:\\n for line in f:\\n line = int(line.split()[1]) - 1\\n counts[line] += 1\\n\\n return counts\",\n \"def __len__(self) -> int:\\n return self._num_ann\",\n \"def num_inducing(self) -> tf.Tensor:\\n raise NotImplementedError\",\n \"def counts(self):\\n\\n counts = defaultdict(int)\\n\\n for i, geom in zip(self.tree_ids, self.tree):\\n point_int = list(self.sindex.intersection(geom.bounds))\\n if point_int:\\n counts[i] += len(point_int)\\n\\n return dict(counts)\",\n \"def count_tags(tag_events):\\n tagged_lines = []\\n for tag_event in tag_events:\\n for tag in tag_event[1][\\\"tag\\\"][\\\"labels\\\"]:\\n tagged_lines.append(tag)\\n tag_counts = Counter(tagged_lines)\\n return tag_counts\",\n \"def gen_img_counts(img_path, model):\\n\\n img = transform(Image.open(img_path).convert('RGB'))\\n print(type(img))\\n output = model(img.unsqueeze(0))\\n pred_count = int(output.detach().cpu().sum().numpy())\\n return pred_count\",\n \"def getClassCounts(b):\\n c = {k:0 for k in labels.keys()}\\n for r in b:\\n c[r[0]] += 1\\n return c\",\n \"def get_label_counts(dataset_path: str):\\n if not dataset_path:\\n return None\\n td = ImageFolder(root=dataset_path)\\n # get label distribution\\n label_counts = [0] * len(td.classes)\\n for p, l in td.samples:\\n label_counts[l] += 1\\n return label_counts\",\n \"def edgecount(self):\\n\\n raise NotImplementedError\",\n \"def count(self):\\r\\n return self.count_helper(self.top_node)\",\n \"def _collect_counts(self, instance_list):\\n \\\"\\\"\\\" Based on each instance, I augment empirical counts for every word and its BIO label in feature_count_table and for every transition from previous label to current label in transition_count_table.\\n All \\\"rare words\\\" (those words that appear less than 3 times) are replaced by <UNK>.\\n I also add label|START counts.\\n \\\"\\\"\\\"\\n # Build feature_count_table of V x labels and transition_count_table of labels x labels\\n for instance in instance_list: # Set of <(w, pos), l>\\n index = 0\\n for t in instance.data: # Tuple of (w, pos)\\n index = instance.data.index(t)\\n # print t[0] # word\\n # print instance.label[index] # label\\n if t in self.V:\\n self.feature_count_table[self.V.index(t)][self.labels.index(instance.label[index])] +=1\\n else:\\n self.feature_count_table[self.V.index('<UNK>')][self.labels.index(instance.label[index])] +=1\\n if index > 0:\\n self.transition_count_table[self.labels.index(instance.label[index-1])][self.labels.index(instance.label[index])] += 1\\n else:\\n self.transition_count_table[len(self.labels)][self.labels.index(instance.label[index])] += 1\",\n \"def count_ones(self):\\r\\n count = 0\\r\\n for x in range(self.xspan):\\r\\n for y in range(self.yspan):\\r\\n if (self.cells[x][y] == 1):\\r\\n count = count + 1\\r\\n return count\",\n \"def n(self):\\n return len(self.marks)\",\n \"def countAtom (dico_count, PDB_parsed, debug = 0):\\n count = 0\\n \\n for atom in PDB_parsed : \\n residue = tool.transformAA(atom[\\\"resName\\\"])\\n if debug : print residue\\n \\n if residue in dico_count : \\n atom_Name = atom[\\\"name\\\"]\\n if atom_Name in dico_count[residue] : \\n count = count + 1\\n return count\",\n \"def getCount(self):\\n return _osgAnimation.Target_getCount(self)\",\n \"def num_links(self):\\n count=0.0\\n for cluster in self.clusters:\\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\\n numberofmembers=self.clusters[cluster].number_of_members\\n count+=numberofmembers\\n return count\",\n \"def class_counts(rows):\\n counts = {} # a dictionary of label -> count.\\n for row in rows:\\n # in our dataset format, the label is always the last column\\n label = row[-1]\\n if label not in counts:\\n counts[label] = 0\\n counts[label] += 1\\n return counts\",\n \"def class_counts(rows):\\n counts = {} # a dictionary of label -> count.\\n for row in rows:\\n # in our dataset format, the label is always the last column\\n label = row[-1]\\n if label not in counts:\\n counts[label] = 0\\n counts[label] += 1\\n return counts\",\n \"def class_counts(rows):\\n counts = {} # a dictionary of label -> count.\\n for row in rows:\\n # in our dataset format, the label is always the last column\\n label = row[-1]\\n if label not in counts:\\n counts[label] = 0\\n counts[label] += 1\\n return counts\",\n \"def num_annuli(self) -> int:\\n return self._num_ann\",\n \"def count_points(roi):\\r\\n # Performing Mean Shift Filtering\\r\\n shifted = cv2.pyrMeanShiftFiltering(roi, 21, 51)\\r\\n\\r\\n # Converting the image to grayscale\\r\\n gray = cv2.cvtColor(shifted, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Thresholding using Binary and OTSU\\r\\n thrsh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]\\r\\n # Using Watershed Algorithm\\r\\n D = ndimage.distance_transform_edt(thrsh)\\r\\n localMax = peak_local_max(D, indices=False, min_distance=1, labels=thrsh)\\r\\n markers = ndimage.label(localMax)[0]\\r\\n lbls = watershed(-D, markers, mask=thrsh)\\r\\n \\r\\n return lbls, len(np.unique(lbls)) - 1\",\n \"def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\\n return Counter(_naked_names_iter(graph))\",\n \"def count_gates(qobj, basis, qubits):\\n\\n #TO DO\\n pass\",\n \"def count_segments(markers) -> int:\\n cnt = Counter()\\n for row in markers:\\n cnt.update(row)\\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\\n del n_cnt[1]\\n del n_cnt[-1]\\n return len(n_cnt.keys())\",\n \"def amine(listAmine, count):\\n \\n for type in listAmine.keys():\\n for nitrogen in listAmine[type]:\\n nbNeighbor = numberNeigthbor(nitrogen[\\\"neighbors\\\"])\\n for neighbor in nitrogen[\\\"neighbors\\\"]:\\n if not nbNeighbor in count[type].keys():\\n count[type][nbNeighbor] = structure.countElements()\\n if not nbNeighbor in count[\\\"GlobalAmine\\\"].keys():\\n count[\\\"GlobalAmine\\\"][nbNeighbor] = structure.countElements()\\n\\n\\n if neighbor[\\\"element\\\"] in count[type][nbNeighbor].keys():\\n count[type][nbNeighbor][neighbor[\\\"element\\\"]] = count[type][nbNeighbor][neighbor[\\\"element\\\"]] + 1\\n count[\\\"GlobalAmine\\\"][nbNeighbor][neighbor[\\\"element\\\"]] = count[\\\"GlobalAmine\\\"][nbNeighbor][neighbor[\\\"element\\\"]] + 1\\n\\n else:\\n count[type][nbNeighbor][\\\"others\\\"] = count[type][nbNeighbor][\\\"others\\\"] + 1\\n count[\\\"GlobalAmine\\\"][nbNeighbor][\\\"others\\\"] = count[\\\"GlobalAmine\\\"][nbNeighbor][\\\"others\\\"] + 1\",\n \"def label_stats(label_mapping):\\n\\tlabels = list(label_mapping.values())\\n\\n\\tfor count, elem in sorted(((labels.count(e), e) for e in set(labels)), reverse=True):\\n\\t\\tprint('%s: \\\\t\\\\t %d' % (elem, count))\",\n \"def numnems(self):\\n count = 0\\n for o in self._objs.values():\\n count += len(o.netifs())\\n return count\",\n \"def count_nodes(self):\\n\\t\\treturn self.__count_nodes(self)\",\n \"def get_num_of_images(self):\",\n \"def get_marble_count(self):\",\n \"def annotations_per_batch(self):\\n if self._batch_size is None or self.task in {'objdet', 'sggen'}:\\n return self._annotations_per_batch\\n annos_per_img = self._annos_per_img[self.dataset]\\n if self.task in {'predcls', 'sgcls'}:\\n annos_per_img = annos_per_img['pairs']\\n elif self.task == 'objcls':\\n annos_per_img = annos_per_img['objects']\\n elif self.task == 'preddet' and self.filter_multiple_preds:\\n annos_per_img = annos_per_img['predicates_filtered']\\n elif self.task == 'preddet' and self.filter_duplicate_rels:\\n annos_per_img = annos_per_img['duplicates_filtered']\\n elif self.task == 'preddet':\\n annos_per_img = annos_per_img['relations']\\n return annos_per_img * self._batch_size\",\n \"def get_tag_counts(label_matches):\\r\\n\\ttag_counts = {}\\r\\n\\tfor word_and_tag in label_matches.keys():\\r\\n\\t\\tcurrent_count = tag_counts.get(word_and_tag[_TAG], 0)\\r\\n\\t\\ttag_counts[word_and_tag[_TAG]] = current_count+1\\r\\n\\treturn tag_counts\",\n \"def entity_counts(doc):\\n \\n tags = []\\n for token in doc.ents:\\n tags.append(token.label_)\\n frequency = dict(Counter(tags).most_common())\\n\\n return frequency\",\n \"def number_of_running_metrics(self):\\n try:\\n return len(self.get_classads(\\\"OSGRSV==\\\\\\\"metrics\\\\\\\"\\\"))\\n except TypeError:\\n self.rsv.log(\\\"ERROR\\\", \\\"Classad parsing failed, unable to count running metrics\\\")\",\n \"def count_taxa_tree(tree_nxobj):\\n\\tnode_count = 0 #number of taxa in the tree\\n\\tfor node in tree_nxobj.preorder_node_iter():\\n\\t\\tnode_count += 1\\n\\n\\treturn node_count\",\n \"def count_each_tag(mat):\\n cnts = {}\\n for vec in mat:\\n if vec[-1] not in cnts:\\n cnts[vec[-1]] = 0.0\\n cnts[vec[-1]] += 1.0\\n return cnts\",\n \"def count_relations(graph):\\n return Counter(\\n data[RELATION]\\n for _, _, data in graph.edges_iter(data=True)\\n )\",\n \"def get_nodes_pixel_count(self):\\n sum_count = self.pixel_count\\n for i in range(8):\\n node = self.children[i]\\n if node:\\n sum_count += node.pixel_count\\n return sum_count\",\n \"def _collect_counts(self):\\n for t in self.system.keys():\\n if t in self.gold:\\n self.tp += 1\\n else:\\n self.fp += 1\\n for t in self.gold.keys():\\n if t not in self.system:\\n self.fn += 1\",\n \"def __init__(self):\\n self.num_counts = {}\",\n \"def count_labels(self, add_no_ne_label=False):\\n return sum([count[1] for count in self.get_label_counts(add_no_ne_label=add_no_ne_label)])\",\n \"def count(self, trace):\\n return len(trace)\",\n \"def count_elements_in_dataset(dataset):\\n return dataset.count()\",\n \"def count(self):\\n # TODO not implemented yet\\n return 0\",\n \"def getCounts():\\n for area in AREAS:\\n print(area['name'])\\n lat = area['lat']\\n lng = area['lng']\\n count = utils.getExtracted(countCrimes, lat, lng)\\n print('count: %s' % count)\\n if type(count) is list:\\n area['count'] = count[0]\\n return AREAS\",\n \"def number_tokens(dgraph):\\n cnt = 0\\n for node in dgraph.subgraphs(exclude_root=True):\\n node[WORD] = (cnt, node[WORD])\\n cnt += 1\\n return dgraph\",\n \"def get_correct_lap_count(self):\",\n \"def graphToStatCount(node, tag):\\n if ':' in tag:\\n tag = tag.split(':')[-1]\\n s = StatCount(node.tag)\\n if node.tag != 'stats':\\n s.nodeTranscripts = int(node.attrib['transcripts'])\\n s.nodeTranscriptAnnotations = int(node.attrib['transcript_annotations'])\\n if node.tag == tag or tag == '*':\\n s.tagTranscripts = s.nodeTranscripts\\n s.tagTranscriptAnnotations = s.nodeTranscriptAnnotations\\n for child in node:\\n s.children.append(graphToStatCount(child, tag))\\n if node.tag == 'stats':\\n for child in s.children:\\n s.nodeTranscripts += child.nodeTranscripts\\n s.nodeTranscriptAnnotations += child.nodeTranscriptAnnotations\\n return s\",\n \"def num_regions(image_data):\\n if len(image_data.shape) > 2:\\n image_data = skimage.color.rgb2gray(image_data)\\n _, num_labels = ndimage.label(image_data)\\n return num_labels\",\n \"def atom_count(self):\\n return len(self.repeated_elements())\",\n \"def count(self):\\n return self.__tree.node_count\",\n \"def count_passages(self, step, count):\\r\\n count = int(count)\\r\\n assert_equals(len(world.css_find('.annotatable-span')), count)\\r\\n assert_equals(len(world.css_find('.annotatable-span.highlight')), count)\\r\\n assert_equals(len(world.css_find('.annotatable-span.highlight-yellow')), count)\",\n \"def num_anchors_per_location(self):\\n pass\",\n \"def label_counts(rows):\\n counts = rows.iloc[:, -1].value_counts()\\n return counts\",\n \"def count_params():\\n param_count = np.sum([np.prod(x.get_shape().as_list()) for x in tf.global_variables()])\\n return param_count\",\n \"def get_count(self, using):\\n obj = self.clone()\\n obj.add_annotation(SphinxCount('*'), alias='__count', is_summary=True)\\n number = obj.get_aggregation(using, ['__count'])['__count']\\n if number is None:\\n number = 0\\n return number\",\n \"def generate_feature_counts(traj, mdp):\\n #count each time a state was visited \\n counts = Counter({feature:0 for feature in mdp.features})\\n for state,action in traj:\\n counts[mdp.observe_features(state)] += 1\\n \\n return [counts[feature] for feature in mdp.features]\",\n \"def sample_count(self):\",\n \"def _count(self):\\n words = [word.lower() for word in self.corpus.words()]\\n bigrams_words = bigrams(words)\\n for bigram in bigrams_words:\\n self._bigrams[bigram] += 1\",\n \"def test_calculate_count(request):\\n print(\\\"\\\\n--Starting:\\\", request.node.name)\\n\\n net = ModelRoadwayNetwork.read(\\n link_file=STPAUL_LINK_FILE,\\n node_file=STPAUL_NODE_FILE,\\n shape_file=STPAUL_SHAPE_FILE,\\n fast=True,\\n )\\n\\n net.add_counts()\\n assert \\\"AADT\\\" in net.links_df.columns\\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\\n ## todo write an assert that actually tests something\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8343825","0.75170594","0.68242604","0.6573023","0.64739114","0.6471781","0.6350306","0.6324876","0.6313155","0.62601817","0.6247608","0.6229666","0.6193566","0.6186364","0.61589694","0.6157267","0.6121791","0.6050442","0.6028076","0.60266453","0.60266453","0.60266453","0.60266453","0.60212284","0.6016933","0.60095996","0.59944993","0.5985487","0.5972277","0.59574944","0.59574944","0.59526944","0.5940211","0.59064674","0.5906015","0.5889946","0.58869123","0.5868948","0.5866724","0.5848382","0.584823","0.58291477","0.582594","0.5821544","0.58201396","0.5811961","0.58099556","0.579783","0.5793088","0.5784733","0.5779139","0.5768086","0.5756378","0.57484996","0.57431555","0.57389635","0.57291186","0.57291186","0.57291186","0.5723297","0.5722781","0.571844","0.5697956","0.5697098","0.56967235","0.5696191","0.5692324","0.56840515","0.5682915","0.56795424","0.5668537","0.5664838","0.56636465","0.5654473","0.5653096","0.56496716","0.5644683","0.5638912","0.5636785","0.5635354","0.5630416","0.5628804","0.5622996","0.5620484","0.5607095","0.5597692","0.55957574","0.55920064","0.55913025","0.55872136","0.55867225","0.558416","0.55826503","0.5582077","0.5576004","0.5574156","0.5563467","0.5554159","0.55525565","0.55519444"],"string":"[\n \"0.8343825\",\n \"0.75170594\",\n \"0.68242604\",\n \"0.6573023\",\n \"0.64739114\",\n \"0.6471781\",\n \"0.6350306\",\n \"0.6324876\",\n \"0.6313155\",\n \"0.62601817\",\n \"0.6247608\",\n \"0.6229666\",\n \"0.6193566\",\n \"0.6186364\",\n \"0.61589694\",\n \"0.6157267\",\n \"0.6121791\",\n \"0.6050442\",\n \"0.6028076\",\n \"0.60266453\",\n \"0.60266453\",\n \"0.60266453\",\n \"0.60266453\",\n \"0.60212284\",\n \"0.6016933\",\n \"0.60095996\",\n \"0.59944993\",\n \"0.5985487\",\n \"0.5972277\",\n \"0.59574944\",\n \"0.59574944\",\n \"0.59526944\",\n \"0.5940211\",\n \"0.59064674\",\n \"0.5906015\",\n \"0.5889946\",\n \"0.58869123\",\n \"0.5868948\",\n \"0.5866724\",\n \"0.5848382\",\n \"0.584823\",\n \"0.58291477\",\n \"0.582594\",\n \"0.5821544\",\n \"0.58201396\",\n \"0.5811961\",\n \"0.58099556\",\n \"0.579783\",\n \"0.5793088\",\n \"0.5784733\",\n \"0.5779139\",\n \"0.5768086\",\n \"0.5756378\",\n \"0.57484996\",\n \"0.57431555\",\n \"0.57389635\",\n \"0.57291186\",\n \"0.57291186\",\n \"0.57291186\",\n \"0.5723297\",\n \"0.5722781\",\n \"0.571844\",\n \"0.5697956\",\n \"0.5697098\",\n \"0.56967235\",\n \"0.5696191\",\n \"0.5692324\",\n \"0.56840515\",\n \"0.5682915\",\n \"0.56795424\",\n \"0.5668537\",\n \"0.5664838\",\n \"0.56636465\",\n \"0.5654473\",\n \"0.5653096\",\n \"0.56496716\",\n \"0.5644683\",\n \"0.5638912\",\n \"0.5636785\",\n \"0.5635354\",\n \"0.5630416\",\n \"0.5628804\",\n \"0.5622996\",\n \"0.5620484\",\n \"0.5607095\",\n \"0.5597692\",\n \"0.55957574\",\n \"0.55920064\",\n \"0.55913025\",\n \"0.55872136\",\n \"0.55867225\",\n \"0.558416\",\n \"0.55826503\",\n \"0.5582077\",\n \"0.5576004\",\n \"0.5574156\",\n \"0.5563467\",\n \"0.5554159\",\n \"0.55525565\",\n \"0.55519444\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8530131"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20160,"cells":{"query":{"kind":"string","value":"Gets the set of annotations used in the graph"},"document":{"kind":"string","value":"def get_annotations(graph):\n return set(_annotation_iter_helper(graph))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def annotations(self):\n return self._annotations","def annotations(self):\n\n return self._annotations","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\n return pulumi.get(self, \"annotations\")","def GetAnnotationsQS(self):\n return self._costly_annotations_qs","def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))","def get_unused_annotations(graph):\n return graph.defined_annotation_keywords - get_annotations(graph)","def annotations(self):\n\t\tif self._record is not None:\n\t\t return self._record.annotations\n\t\telse:\n\t\t return {}","def annotations(self) -> Iterator['Annotation']:\n return itertools.chain(self.footnotecitations.all(),\n self.cites.all(),\n self.externallinks.all(),\n self.inlinerequirements.all())","def get_annotations(self, img_id):\n return self._img_id2annotations.get(img_id, [])","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def get_annotations(self):\n entity = self.get_object()\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\n return Response(serializer.data)","def _annotation_iter_helper(graph):\n return (\n key\n for _, _, data in graph.edges(data=True)\n if ANNOTATIONS in data\n for key in data[ANNOTATIONS]\n )","def get_annotation_count(self):\n return self._num_annos","def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\n annotations = []\n for item in self.collector:\n data_file_type = os.path.basename(item).split(\".\")[-1]\n annotations.append(\n load_annotation_file(\n os.path.join(\n self.annotation_folder,\n os.path.basename(item).replace(data_file_type, \"json\"),\n )\n )\n )\n\n return annotations","def _annotations(request):\n result = Search(request).run(MultiDict(request.params))\n\n return request.find_service(AnnotationReadService).get_annotations_by_id(\n ids=result.annotation_ids\n )","def _get_corner_annotations_visibility(self) :\n \n return self._corner_annotations_visibility","def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def get_annotations(self):\n ann = wfdb.rdann(self.patient_number, 'atr', pb_dir='mitdb', return_label_elements=['symbol', 'label_store',\n 'description'],\n summarize_labels=True)\n\n mit_bih_labels_str = ann.symbol\n\n labels_locations = ann.sample\n\n labels_description = ann.description\n\n return mit_bih_labels_str, labels_locations, labels_description","def get_alignable_annotations(self, root):\n\n aas = root.findall(\".//ALIGNABLE_ANNOTATION\")\n return {aa.attrib[\"ANNOTATION_ID\"]: aa for aa in aas}","def _used_annotations(cls) -> set:\n return set(field.type for field in dataclasses.fields(cls))","def extract_annotations(self, min_annot=3):\n for g in self.games:\n annotation_list = [move.strip(\"{}\") for move in g.moves if move.strip().startswith(\"{\")]\n if len(annotation_list) < min_annot:\n continue\n\n annotation = \" \".join(annotation_list)\n self.annotations.append(annotation)","def get_overview_annotations() -> dict:\n return {}","def audit_annotations(self) -> Optional[Sequence['outputs.AuditAnnotation']]:\n return pulumi.get(self, \"audit_annotations\")","def _load_annotations(self):\n if self._raw_annotations is not None:\n return self._raw_annotations\n\n dataset_file = os.path.join(self._annotation_path, 'complete_dataset_v{}.pkl'.format(self._version))\n idx_file = os.path.join(self._annotation_path, 'splits_indices_v{}.pkl'.format(self._version))\n\n def get_split_from_ds(ds, idx):\n split = {}\n keys = sorted(ds.keys())\n for j in xrange(len(idx)):\n k = keys[idx[j]]\n split[k] = ds[k]\n return split\n\n with open(idx_file, 'rb') as fid:\n indices = cPickle.load(fid)[self._image_set]\n with open(dataset_file, 'rb') as fid:\n ds = cPickle.load(fid)\n self._raw_annotations = get_split_from_ds(ds, indices)\n\n return self._raw_annotations","def get_annotations(xmlsent):\n annotations = []\n annotation_elements = xmlsent.findall(\".//{%s}a\" % NS)\n for element in annotation_elements:\n annotation = {}\n annotation['type'] = element.attrib.get('type')\n annotation['flavor'] = element.attrib.get('flavor')\n annotation['who'] = element.attrib.get('who')\n annotation['text'] = element.text\n annot = {'type': element.attrib.get('type'), 'flavor': element.attrib.get('flavor'), \n 'who': element.attrib.get('who'), 'text': element.text}\n annotations.append(annot)\n return annotations","def all_annotation_fns(self):\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]","def audit_annotations(self) -> Optional[Sequence['outputs.AuditAnnotationPatch']]:\n return pulumi.get(self, \"audit_annotations\")","def load_annotations(self, index):\n anns_file = open(os.path.join(self.folder_path, self.image_ids[index] + '.json'))\n labels = json.load(anns_file)\n labels = labels[\"shapes\"]\n anns_file.close()\n return labels.copy()","def annotations(self, annotations):\n self._annotations = annotations","def getAnnotation(self, *args):\n return _libsbml.SBase_getAnnotation(self, *args)","def inspect_ann(node):\n if node.annotation is not None:\n return [{\"name\": \"annotation\", \"line\": node.annotation.lineno - 1, \"end_line\": node.annotation.end_lineno - 1,\n \"col_offset\": node.annotation.col_offset, \"end_col_offset\": node.annotation.end_col_offset,\n \"var_line\": node.lineno - 1, \"var_end_line\": node.end_lineno - 1, \"var_col_offset\": node.col_offset,\n \"var_end_col_offset\": node.end_col_offset}]\n else:\n return []","def needsAnnotationsDictionary(self):\n return self.needs_annotations_dict","def _get_annotations(self, node, offset_mngr):\n for anno in self._iterfind(node, 'annotation'):\n offsets = list(self._get_offsets(anno, offset_mngr))\n yield self._entity(anno, offsets)","def _load_annotations(self):\n annotation_file = self._filepath(self.ANNOTATION_FILE)\n with open(annotation_file) as f:\n json_data = json.load(f)\n\n return json_data","def get_annotation_names(viewer):\n\n layer_nodes_name = None\n layer_edges_name = None\n for layer in viewer.layers:\n if isinstance(layer, napari.layers.points.points.Points):\n layer_nodes_name = layer.name\n elif isinstance(layer, napari.layers.shapes.shapes.Shapes):\n layer_edges_name = layer.name\n if layer_nodes_name is not None and layer_edges_name is not None:\n break\n return layer_nodes_name, layer_edges_name","def get_analysis_annotations():\n sample_id = demisto.getArg('id')\n r = req('GET', SUB_API + 'samples/' + sample_id + '/analysis/annotations')\n\n annotations = []\n context_path = 'ThreatGrid.AnalysisResults.Sample.Id.Annotations'\n ec = {context_path: []} # type: ignore\n ips = demisto.get(r.json(), 'data.items.network') # type: ignore\n if ips:\n for k in ips:\n annotation = {\n 'IP': k,\n 'IP.Asn': ips[k].get('asn'),\n 'IP.City': ips[k].get('city'),\n 'IP.Country': ips[k].get('country'),\n 'IP.Org': ips[k].get('org'),\n 'IP.Region': ips[k].get('region'),\n 'IP.Timestamp': ips[k].get('ts')\n }\n annotations.append(annotation)\n ec[context_path].append(annotation)\n\n demisto.results({\n 'Type': entryTypes['note'],\n 'ContentsFormat': formats['json'],\n 'Contents': r.json(),\n 'EntryContext': ec,\n 'HumanReadable': tableToMarkdown('ThreatGrid - Analysis Annotations', annotations, [\n 'IP', 'IP.Asn', 'IP.City', 'IP.Country', 'IP.Org', 'IP.Region', 'IP.Timestamp'\n ])\n })","def get_filtered_dataset_annotations(config):\n\n images_filenames = net.data.get_dataset_filenames(\n config[\"voc\"][\"data_directory\"], config[\"voc\"][\"validation_set_path\"])\n\n annotations_paths = [os.path.join(config[\"voc\"][\"data_directory\"], \"Annotations\", image_filename + \".xml\")\n for image_filename in images_filenames]\n\n labels_to_categories_index_map = {label: index for (index, label) in enumerate(config[\"categories\"])}\n\n all_annotations = []\n\n for annotations_path in tqdm.tqdm(annotations_paths):\n\n with open(annotations_path) as file:\n\n image_annotations_xml = xmltodict.parse(file.read())\n\n image_size = \\\n int(image_annotations_xml[\"annotation\"][\"size\"][\"height\"]), \\\n int(image_annotations_xml[\"annotation\"][\"size\"][\"width\"])\n\n # Read annotations\n annotations = net.data.get_objects_annotations(\n image_annotations=image_annotations_xml,\n labels_to_categories_index_map=labels_to_categories_index_map)\n\n # Resize annotations in line with how we would resize the image\n annotations = [annotation.resize(image_size, config[\"size_factor\"]) for annotation in annotations]\n\n # Discard odd sized annotations\n annotations = \\\n [annotation for annotation in annotations\n if not net.utilities.is_annotation_size_unusual(annotation, **config[\"objects_filtering\"])]\n\n all_annotations.extend(annotations)\n\n return all_annotations","def _get_annotation(self, image_id):\n annotation_file = self.image_sets_dir / f'{image_id}.xml'\n objects = ET.parse(annotation_file).findall('object')\n boxes = []\n labels = []\n is_difficult = []\n for obj in objects:\n class_name = obj.find('name').text.lower().strip()\n if class_name in self.class_dict:\n bbox = obj.find('bndbox')\n\n x0 = float(bbox.find('xmin').text) - 1\n y0 = float(bbox.find('ymin').text) - 1\n x1 = float(bbox.find('xmax').text) - 1\n y1 = float(bbox.find('ymax').text) - 1\n boxes.append([x0, y0, x1, y1])\n\n labels.append(self.class_dict[class_name])\n\n is_difficult_str = obj.find('difficult').text\n is_difficult.append(int(is_difficult_str) if is_difficult_str else 0)\n\n return (np.array(boxes, dtype=np.float32),\n np.array(labels, dtype=np.int64),\n np.array(is_difficult, dtype=np.uint8))","def annotations(self):\n annotations = {\"date\": self.date_trunc(\"usage_start\")}\n # { query_param: database_field_name }\n fields = self._mapper.provider_map.get(\"annotations\")\n for q_param, db_field in fields.items():\n annotations[q_param] = F(db_field)\n if (\n \"project\" in self.parameters.parameters.get(\"group_by\", {})\n or \"and:project\" in self.parameters.parameters.get(\"group_by\", {})\n or \"or:project\" in self.parameters.parameters.get(\"group_by\", {})\n ):\n annotations[\"project\"] = F(\"namespace\")\n\n return annotations","def annotation(self):\n return (self._name, self._value)","def load_annotations(self):\n if self.ann_file.endswith('.json'):\n return self.load_json_annotations()\n\n video_infos = []\n with open(self.ann_file, 'r') as fin:\n for line in fin:\n line_split = line.strip().split()\n if self.multi_class:\n assert self.num_classes is not None\n filename, label = line_split[0], line_split[1:]\n label = list(map(int, label))\n else:\n filename, label = line_split\n label = int(label)\n if self.data_prefix is not None:\n filename = osp.join(self.data_prefix, filename)\n video_infos.append(dict(filename=filename, label=label))\n while len(video_infos) < self.min_video_num:\n left_num = min(self.min_video_num - len(video_infos), len(video_infos))\n video_infos.extend(random.sample(video_infos, left_num))\n return video_infos","def get_labels(self) -> Set[str]:","def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))","def annotations_per_batch(self):\n if self._batch_size is None or self.task in {'objdet', 'sggen'}:\n return self._annotations_per_batch\n annos_per_img = self._annos_per_img[self.dataset]\n if self.task in {'predcls', 'sgcls'}:\n annos_per_img = annos_per_img['pairs']\n elif self.task == 'objcls':\n annos_per_img = annos_per_img['objects']\n elif self.task == 'preddet' and self.filter_multiple_preds:\n annos_per_img = annos_per_img['predicates_filtered']\n elif self.task == 'preddet' and self.filter_duplicate_rels:\n annos_per_img = annos_per_img['duplicates_filtered']\n elif self.task == 'preddet':\n annos_per_img = annos_per_img['relations']\n return annos_per_img * self._batch_size","def entities(self):\n if 'ner' not in self.annotators:\n return None\n return [t[self.NER] for t in self.data]","def entities(self):\n if 'ner' not in self.annotators:\n return None\n return [t[self.NER] for t in self.data]","def type_hint_annotations(self) -> list[FakeAnnotation]:\n result: list[FakeAnnotation] = []\n for child in self.children:\n if child.type_annotation.get_local_types():\n result.append(child.type_annotation)\n return result","def get_aliens(self):\n return self._aliens","def generate_annotations(self, caching=CachingType.NONE):\n # Make the nltk Text list of words\n text = self.nltk_text(self.text)\n\n # Get the uncommon_words\n uncommon_words = self.eliminate_common(text)\n # Get the places / VIPs / hystorical events / etc.\n extras = self.get_extras(text)\n # Generate the annotations\n annotations = []\n for word in uncommon_words:\n ann = annot.TextAnnotation(word, AnnotationType.UNCOMMON_WORD,\n caching)\n ann.save_to_db()\n if ann.data is None or not ann.data:\n continue\n annotations.append(ann)\n for word in extras:\n ann = annot.TextAnnotation(word, AnnotationType.EXTRA, caching)\n ann.save_to_db(case_sensitive=True)\n if ann.data is None or not ann.data:\n continue\n annotations.append(ann)\n # Return the list of annotations\n return annotations","def extract_annotations(chosen_classes, annotations_dir, dataset_dir, val_set, train_set): \n extension = ''\n annotations_train = []\n annotations_val = []\n class_names = set()\n for xml_file in [f for f in os.listdir(annotations_dir) if f.endswith(\".xml\")]:\n tree = ET.parse(os.path.join(annotations_dir, xml_file))\n root = tree.getroot()\n file_name = None\n image = xml_file[:-3] \n try: \n extension = [image_file for image_file in os.listdir(dataset_dir) if image_file.split('.')[0]==image[:-1]][0].split('.')[1]\n \n if os.path.exists(dataset_dir + image+extension):\n for elem in root:\n if elem.tag == 'filename':\n file_name = os.path.join(dataset_dir, image+extension)\n if elem.tag == 'object':\n obj_name = None\n coords = []\n for subelem in elem:\n if subelem.tag == 'name':\n obj_name = subelem.text \n if subelem.tag == 'bndbox':\n for subsubelem in subelem:\n coords.append(subsubelem.text)\n item = [file_name] + coords + [obj_name]\n if obj_name in chosen_classes:\n class_names.add(obj_name)\n if xml_file in val_set:\n annotations_val.append(item)\n elif xml_file in train_set:\n annotations_train.append(item)\n except:\n print(\"Image file for xml with name: \", xml_file, \" does not seem to exist!\")\n return annotations_train, annotations_val, class_names","def encode_annotations(self, documents:List[Document]):\n\n # Loop over documents\n labels = []\n for doc in documents:\n # Loop over sentences\n label_index =[]\n for sentence in doc.sentences:\n #Loop over tokens\n for token in sentence.tokens:\n #convert label to numerical representation\n label_index.append(self.labels2index[token.label])\n\n labels.append(label_index)\n\n return labels","def _parse_anno_info(self, annotations):\n gt_bboxes, gt_bboxes_ignore = [], []\n gt_masks, gt_masks_ignore = [], []\n gt_labels = []\n for ann in annotations:\n if ann.get('iscrowd', False):\n gt_bboxes_ignore.append(ann['bbox'])\n gt_masks_ignore.append(ann.get('segmentation', None))\n else:\n gt_bboxes.append(ann['bbox'])\n gt_labels.append(ann['category_id'])\n gt_masks.append(ann.get('segmentation', None))\n if gt_bboxes:\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\n gt_labels = np.array(gt_labels, dtype=np.int64)\n else:\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\n gt_labels = np.array([], dtype=np.int64)\n\n if gt_bboxes_ignore:\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\n else:\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\n\n ann = dict(\n bboxes=gt_bboxes,\n labels=gt_labels,\n bboxes_ignore=gt_bboxes_ignore,\n masks_ignore=gt_masks_ignore,\n masks=gt_masks)\n\n return ann","def _init_annotation(self):\n annotations = []\n for frame in self.frames:\n coordinates, sources, targets, ids = [], [], [], []\n frame_id = set()\n for spot_id, spot_annot in frame.items():\n coordinates.append((spot_annot[\"x\"], spot_annot[\"y\"]))\n sources.append(spot_annot[\"source\"])\n targets.append(spot_annot[\"target\"])\n ids.append(spot_id)\n frame_id.add(spot_annot[\"frame\"])\n if len(frame_id) != 1:\n raise ValueError(f\"Invalid frame number found in spot: {spot_id}\")\n annotations.append((\n np.array(coordinates, dtype=np.float),\n np.array(sources, dtype=np.str),\n targets,\n np.array(ids, dtype=np.str),\n frame_id.pop()))\n self.annotations = annotations","def load_annos(self):\n data = None\n with open(self.anno_path, 'r') as file:\n if self.ext == '.json':\n data = json.load(file)\n\n # Label start at index 0\n if data is not None:\n for anno in data['annotations']:\n anno['category_id'] -= 1\n\n for anno in data['categories']:\n anno['id'] -= 1\n\n return data","def metric_annotations_allow_list(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"metric_annotations_allow_list\")","def _get_annotation(cls, name):\n return cls.__annotations__.get(name)","def get_annotation_gene_types(args):\n ref_mgr = ReferenceManager(args.reference_path)\n tss = BedTool(ref_mgr.tss_track)\n if tss.field_count() == 7:\n return TRANSCRIPT_ANNOTATION_GENE_TYPES\n else:\n return None","def getAnnotationString(self, *args):\n return _libsbml.SBase_getAnnotationString(self, *args)","def Markers(cls):\n return cls._markers","def __resolve_annotation_conflicts(self, annotations):\n # set the bounding box and initial positions of the annotations\n # the x-value is only corrected if it is inside the graph or too close to the graph\n left = []\n right = []\n for a in annotations:\n # first, get the bounds\n self.__set_annotation_bbox(a)\n\n # now set the intitial positions\n # we want all of the text to be on the left or right of the squares\n width = a.bbox.width\n # to preserve hint values, only set the x value if it is inside the graph\n # or if it is not at least as far as the offset\n if a.y >= 0 and a.y <= self.ymax:\n if ((a.x >= self.xmax / 2) and (a.x < self.xmax)) or (a.x >= self.xmax and a.x < self.xmax + self.settings.otherParams[\"annotation.right.offset\"]):\n a.x = self.xmax + \\\n self.settings.otherParams[\"annotation.right.offset\"]\n elif ((a.x >= 0) and (a.x < self.xmax / 2)) or (a.x <= self.xmin and a.x > self.xmin - self.settings.otherParams[\"annotation.left.offset\"]):\n a.x = self.xmin - \\\n self.settings.otherParams[\"annotation.left.offset\"] - width\n a.bbox.x0 = a.x\n a.bbox.x1 = a.x + width\n if (a.x >= self.xmax / 2):\n a.set_relpos((0, 0.5))\n right.append(a)\n if (a.x < self.xmax / 2):\n a.set_relpos((1, 0.5))\n left.append(a)\n elif a.y < 0:\n a.set_relpos((0.5, 0))\n right.append(a)\n elif a.y > self.ymax:\n a.set_relpos((0.5, 1))\n right.append(a)\n\n # for the left, we want to prioritze labels\n # with lower x values to minimize the crossover of annotation lines\n # for the right, we want to prioritize labels that are closer\n # to the right side of the graph to minimuze the crossover of annotation lines\n left.sort(key=lambda a: (a.event_point.y, a.event_point.x))\n right.sort(key=lambda a: (a.event_point.y, -a.event_point.x))\n\n final = []\n for lst in [left, right]:\n _f = []\n for unchecked in lst:\n for checked in _f:\n if unchecked.overlaps(checked):\n correction = unchecked.get_xy_correction(\n checked, self.label_space_epsilon)\n unchecked.update_Y_with_correction(correction)\n if unchecked.is_within_epsilon_of(checked, self.label_space_epsilon):\n correction = [0, self.label_space_epsilon]\n unchecked.update_Y_with_correction(correction)\n _f.append(unchecked)\n final.extend(_f)\n\n return final","def get_unused_list_annotation_values(graph):\n result = {}\n for annotation, values in graph.annotation_list.items():\n used_values = get_annotation_values(graph, annotation)\n if len(used_values) == len(values): # all values have been used\n continue\n result[annotation] = set(values) - used_values\n return result","def get_all_anns(filepaths):\n annotations = []\n for filepath in filepaths:\n with open(filepath, 'r') as f:\n for line in f:\n ent = line.split('\\t')[0].strip()\n tag = line.split('\\t')[-1].strip()\n # get rid of newlines\n if ent != '' and tag != '':\n annotations.append((ent, tag))\n\n return annotations","def get_annotations_for_person(self, person_id: int) -> np.ndarray:\n return self._get_annotations_for_person_or_pose(person_id, np.array(['personAIK']))","def dump_annotations(self):\n fname = 'annotations'\n if self.split is not None:\n fname = 'annotations_{}'.format(self.split)\n fname = os.path.join(self.dest_folder, '{}.json'.format(fname))\n self.save(self.dataset, fname, \"annotations\")","def get_annotation_dataframe(self):\n return pd.DataFrame(self.annotation_line_list)","def get_annotation_object(annots_path):\n\n lines = annots_path.read_text().split('\\n')\n \n annots = []\n for line in lines:\n if not line:\n continue\n \n annot = {}\n splot = line.split(' ')\n annot['class_id'] = int(splot[0])\n annot['center_x'] = float(splot[1])\n annot['center_y'] = float(splot[2])\n annot['width'] = float(splot[3])\n annot['height'] = float(splot[4])\n annot['class_name'] = splot[-1]\n \n if splot[5].startswith('px:'):\n px = splot[5].strip('px:')\n py = splot[6].strip('py:')\n \n if not (px == 'auto'):\n px = px.split(',')\n py = py.split(',')\n annot['px'] = [float(x) for x in px]\n annot['py'] = [float(x) for x in py]\n else:\n annot['px'] = 'auto'\n annot['py'] = 'auto'\n \n elif splot[5].startswith('conf:'):\n annot['conf'] = float(splot[5].split(':')[1])\n\n annots.append(annot)\n \n return annots","def get_annotations(self, table_name: str, annotation_ids: List[int]) -> List[dict]:\n schema_type, AnnotationModel = self._load_model(table_name)\n\n annotations = (\n self.db.cached_session.query(AnnotationModel)\n .filter(AnnotationModel.id.in_(list(annotation_ids)))\n .all()\n )\n\n anno_schema, __ = self.schema.split_flattened_schema(schema_type)\n schema = anno_schema(unknown=INCLUDE)\n try:\n data = []\n\n for anno in annotations:\n anno_data = anno.__dict__\n anno_data[\"created\"] = str(anno_data.get(\"created\"))\n anno_data[\"deleted\"] = str(anno_data.get(\"deleted\"))\n anno_data = {\n k: v for (k, v) in anno_data.items() if k != \"_sa_instance_state\"\n }\n data.append(anno_data)\n\n return schema.load(data, many=True)\n\n except Exception as e:\n logging.exception(e)\n raise NoAnnotationsFoundWithID(annotation_ids) from e","def annotate_images(self) -> Union[int, None]:\n if not self.ann or not self.ns:\n logging.warning(\"Missing annotation or namespace, \"\n \"skipping annotations\")\n return None\n if self.image_ids:\n if len(self.image_ids) == 0:\n logging.error('No image ids to annotate')\n return None\n else:\n map_ann_id = multi_post_map_annotation(self.conn, \"Image\",\n self.image_ids,\n self.ann,\n self.ns)\n return map_ann_id\n return None","def load_annotations(path):\n annotations = joblib.load(path);\n return annotations","def get_annotation_list(\n self,\n project_id: int,\n doc_id: int\n ) -> requests.models.Response:\n return self.get(\n 'v1/projects/{project_id}/docs/{doc_id}/annotations'.format(\n project_id=project_id,\n doc_id=doc_id\n )\n )","def _get_annotations(self, text, language=''):\n body = {\n 'document': {\n 'type': 'PLAIN_TEXT',\n 'content': text,\n },\n 'features': {\n 'extract_syntax': True,\n },\n 'encodingType': 'UTF32',\n }\n if language:\n body['document']['language'] = language\n\n request = self.service.documents().annotateText(body=body)\n response = request.execute()\n tokens = response.get('tokens', [])\n language = response.get('language')\n\n return {'tokens': tokens, 'language': language}","def _get_ann_file(self):\n prefix = 'instances' if 'test' not in self.image_set else 'image_info'\n return os.path.join(self.data_path, 'annotations',\n prefix + '_' + self.image_set + '.json')","def labels_all(self):\n return self._labels_all","def annotation(self, ann_type: str = None):\n if ann_type is None: ann_type = self.ann\n if ann_type != self.ann:\n warnings.warn('Please note that the annotation type is mismatch with the dataset setting!')\n\n if ann_type == 'label':\n xml_path = self.xml_path.format(id=self.id)\n ann = int(ET.parse(xml_path).find('defective').text)\n elif ann_type == 'bbox':\n xml_path = self.xml_path.format(id=self.id)\n objs = ET.parse(xml_path).findall('bbox')\n ann = []\n for ix, bbox in enumerate(objs):\n y1 = int(float(bbox.find('ymin').text))\n y2 = int(float(bbox.find('ymax').text))\n x1 = int(float(bbox.find('xmin').text))\n x2 = int(float(bbox.find('xmax').text))\n ann.append((y1, y2, x1, x2))\n elif ann_type == 'mask':\n mask_path = self.mask_path.format(id=self.id)\n if os.path.exists(mask_path):\n ann = Image.open(mask_path).convert('L')\n else:\n ann = Image.fromarray(np.zeros((512, 512), dtype=np.uint8)).convert('L')\n elif ann_type == 'none':\n ann = []\n else:\n raise NotImplementedError\n return ann","def get_annotations(data_folder):\n annotations_files = os.listdir('data_annotations')\n\n annotations = {}\n for file_name in annotations_files:\n annotation = json.load(\n open(f'{data_folder}/annotations/{file_name}', 'r')\n )\n key = int(annotation['entity_id'])\n annotations[key] = annotation['value']['value']\n\n return annotations","def to_standoff(self):\n tidx, nidx = 1, 1\n all_anns = []\n for a in self.annotations:\n anns = a.to_standoff(tidx, nidx)\n all_anns.extend(anns)\n nidx += len(anns)-1 # all but one are norms\n tidx += 1\n return all_anns","def GetAnnotations(args, messages):\n annotations = getattr(args, 'annotations', {})\n additional_property_messages = []\n if not annotations:\n return None\n\n for key, value in annotations.items():\n additional_property_messages.append(\n messages.V2Key.AnnotationsValue.AdditionalProperty(\n key=key, value=value))\n\n annotation_value_message = messages.V2Key.AnnotationsValue(\n additionalProperties=additional_property_messages)\n\n return annotation_value_message","def graphs(self):\n return self.__graphs","def get_annotated_lines(self):\n lines = [Line(idx + 1, x) for idx, x in enumerate(self.sourcelines)]\n\n try:\n lines[self.lineno - 1].current = True\n except IndexError:\n pass\n\n return lines","def load_annotations(self):\n # get keys\n with open(self.ann_file, 'r') as fin:\n keys = [line.strip().split(' ')[0] for line in fin]\n # get frame index list for LQ frames\n frame_index_list = []\n for i in range(self.num_input_frames):\n # Each clip of Vimeo90K has 7 frames starting from 1. So we use 9\n # for generating frame_index_list:\n # N | frame_index_list\n # 1 | 4\n # 3 | 3,4,5\n # 5 | 2,3,4,5,6\n # 7 | 1,2,3,4,5,6,7\n frame_index_list.append(i + (9 - self.num_input_frames) // 2)\n\n data_infos = []\n for key in keys:\n folder, subfolder = key.split('/')\n lq_paths = []\n for i in frame_index_list:\n lq_paths.append(\n osp.join(self.lq_folder, folder, subfolder, f'im{i}.png'))\n gt_paths = [osp.join(self.gt_folder, folder, subfolder, 'im4.png')]\n\n data_infos.append(\n dict(lq_path=lq_paths, gt_path=gt_paths, key=key))\n\n return data_infos","def ListAnnotations(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def annotations(self, annotations):\n if annotations is None:\n raise ValueError(\"Invalid value for `annotations`, must not be `None`\") # noqa: E501\n\n self._annotations = annotations","def select_annotations(\n self, center_x: int, center_y: int, width: int, height: int\n ) -> List[Annotation]:\n\n box = geometry.box(\n center_x - width // 2,\n center_y - height // 2,\n center_x + width // 2,\n center_y + height // 2,\n )\n\n annotations = [\n self._annotations[pos] for pos in self._tree.intersection(box.bounds)\n ]\n\n for sorter in self._sorters:\n annotations = sorter(annotations)\n return annotations","def _is_annotated(nodes: List[Node]):\n annotated = False\n for node in nodes:\n annotated = annotated or (\n \"quantization_annotation\" in node.meta\n and node.meta[\"quantization_annotation\"]._annotated\n )\n return annotated","def save_annotations(self):\n r = requests.get(\n f'{self.api_host}/v1/entity-annotations?'\n f'annotation_type=Source reliability (binary)&size=100',\n headers=self.get_request_headers()\n )\n\n entity_annotations = r.json().get('entity_annotations')\n\n for annotation in entity_annotations:\n annotation_id = annotation.get('entity_id')\n with open(\n f'{self.data_folder}/annotations/{annotation_id}.json',\n 'w'\n ) as f:\n json.dump(annotation, f)","def getMarkerGenes(self):\n try:\n self.marker_genes = Utils.findMarkers(self.sc_annot, self.de_dict)\n except:\n print(\"Please run getCellTypes first to get cell annotations. This step is needed for marker gene finding.\")","def markers (self):\n return self._markers","def get_labels(self):\n return []","def notifiers(self):\n return self.registry.keys()","def _convert_annotations(self, ast):\n self.annotations = IDLAnnotations(ast)","def get_annotations(tag_repository):\n timeml_tags = (EVENT, TIMEX, ALINK, SLINK, TLINK)\n annotations = { tagname: {} for tagname in timeml_tags }\n event_idx = {}\n timex_idx = {}\n for tag in tag_repository.all_tags():\n if tag.name == EVENT:\n event_idx[tag.attrs[EIID]] = tag\n elif tag.name == TIMEX:\n timex_idx[tag.attrs[TID]] = tag\n for tag in tag_repository.all_tags():\n if tag.name in timeml_tags:\n offsets = get_offsets(tag, event_idx, timex_idx)\n if offsets is not None:\n annotations[tag.name][offsets] = tag.attrs\n return annotations","def getNumSemanticsAnnotations(self):\n return _libsbml.ASTNode_getNumSemanticsAnnotations(self)","def load_annotations(self, image_index):\n\t\t\t# Get ground truth annotations.\n\t\t\tannotations_ids = self.coco.getAnnIds(imgIds=self.image_ids[image_index], iscrowd=False)\n\t\t\tannotations = {'labels': np.empty((0,)), 'bboxes': np.empty((0, 4))}\n\n\t\t\t# If needed get info for masks.\n\t\t\tif self.mask:\n\t\t\t\timport cv2\n\n\t\t\t\t# Get image info.\n\t\t\t\timage_info = self.coco.loadImgs(self.image_ids[image_index])[0]\n\t\t\t\tannotations['masks'] = []\n\n\t\t\t# Some images appear to miss annotations (like image with id 257034).\n\t\t\tif len(annotations_ids) == 0:\n\t\t\t\treturn annotations\n\n\n\t\t\t# Parse annotations\n\t\t\tcoco_annotations = self.coco.loadAnns(annotations_ids)\n\t\t\tfor idx, a in enumerate(coco_annotations):\n\t\t\t\t# Some annotations have basically no width / height, skip them.\n\t\t\t\tif a['bbox'][2] < 1 or a['bbox'][3] < 1:\n\t\t\t\t\tcontinue\n\n\t\t\t\tannotations['labels'] = np.concatenate([annotations['labels'], [self.coco_label_to_label(a['category_id'])]], axis=0)\n\t\t\t\tannotations['bboxes'] = np.concatenate([annotations['bboxes'], [[\n\t\t\t\t\ta['bbox'][0],\n\t\t\t\t\ta['bbox'][1],\n\t\t\t\t\ta['bbox'][0] + a['bbox'][2],\n\t\t\t\t\ta['bbox'][1] + a['bbox'][3],\n\t\t\t\t]]], axis=0)\n\n\t\t\t\t# If needed get annotations for masks.\n\t\t\t\tif self.mask:\n\t\t\t\t\tif 'segmentation' not in a:\n\t\t\t\t\t\traise ValueError('Expected \\'segmentation\\' key in annotation, got: {}'.format(a))\n\n\t\t\t\t\tmask = np.zeros((image_info['height'], image_info['width'], 1), dtype=np.uint8)\n\t\t\t\t\tfor seg in a['segmentation']:\n\t\t\t\t\t\tpoints = np.array(seg).reshape((len(seg) // 2, 2)).astype(int)\n\n\t\t\t\t\t\t# Draw mask.\n\t\t\t\t\t\tcv2.fillPoly(mask, [points.astype(int)], (1,))\n\n\t\t\t\t\tannotations['masks'].append(mask.astype(float))\n\n\n\t\t\treturn annotations","def get_document_annotations(document_id, include_extractions=False, session=konfuzio_session()):\n url = get_document_api_details_url(document_id, include_extractions=include_extractions)\n r = retry_get(session, url)\n annotations = r.json()['annotations']\n not_custom_annotations = annotations\n revised_annotations_and_extractions = [\n x for x in not_custom_annotations if x['revised'] or x['is_correct'] or not x['id']\n ]\n sorted_annotations = sorted(\n revised_annotations_and_extractions, key=lambda x: (x.get('start_offset') is None, x.get('start_offset'))\n )\n logger.info(f'Document with ID {document_id} contains {len(sorted_annotations)} annotations.')\n\n return sorted_annotations","def load_annotations(self, image_index):\n filename = self.image_names[image_index] + '.xml'\n try:\n tree = ET.parse(os.path.join(self.data_dir, 'Annotations', filename))\n return self.__parse_annotations(tree.getroot())\n except ET.ParseError as e:\n raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)\n except ValueError as e:\n raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)","def overlap(annotations1, annotations2):\n return [val for val in annotations1 if val in annotations2]","def define_annotation_list(y_pos, bgcolor, text, colorfont, name, hovertext):\n return dict(\n x = -0,\n y = y_pos,\n xanchor = 'left',\n text = text,\n hovertext = hovertext,\n showarrow = False,\n captureevents = True,\n bgcolor = bgcolor,\n font = { 'size' : 12, 'color' : colorfont },\n height = 14\n )"],"string":"[\n \"def annotations(self):\\n return self._annotations\",\n \"def annotations(self):\\n\\n return self._annotations\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def GetAnnotationsQS(self):\\n return self._costly_annotations_qs\",\n \"def get_annotation_values(graph, annotation):\\n return set(iter_annotation_values(graph, annotation))\",\n \"def get_unused_annotations(graph):\\n return graph.defined_annotation_keywords - get_annotations(graph)\",\n \"def annotations(self):\\n\\t\\tif self._record is not None:\\n\\t\\t return self._record.annotations\\n\\t\\telse:\\n\\t\\t return {}\",\n \"def annotations(self) -> Iterator['Annotation']:\\n return itertools.chain(self.footnotecitations.all(),\\n self.cites.all(),\\n self.externallinks.all(),\\n self.inlinerequirements.all())\",\n \"def get_annotations(self, img_id):\\n return self._img_id2annotations.get(img_id, [])\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def get_annotations(self):\\n entity = self.get_object()\\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\\n return Response(serializer.data)\",\n \"def _annotation_iter_helper(graph):\\n return (\\n key\\n for _, _, data in graph.edges(data=True)\\n if ANNOTATIONS in data\\n for key in data[ANNOTATIONS]\\n )\",\n \"def get_annotation_count(self):\\n return self._num_annos\",\n \"def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\\n annotations = []\\n for item in self.collector:\\n data_file_type = os.path.basename(item).split(\\\".\\\")[-1]\\n annotations.append(\\n load_annotation_file(\\n os.path.join(\\n self.annotation_folder,\\n os.path.basename(item).replace(data_file_type, \\\"json\\\"),\\n )\\n )\\n )\\n\\n return annotations\",\n \"def _annotations(request):\\n result = Search(request).run(MultiDict(request.params))\\n\\n return request.find_service(AnnotationReadService).get_annotations_by_id(\\n ids=result.annotation_ids\\n )\",\n \"def _get_corner_annotations_visibility(self) :\\n \\n return self._corner_annotations_visibility\",\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def get_annotations(self):\\n ann = wfdb.rdann(self.patient_number, 'atr', pb_dir='mitdb', return_label_elements=['symbol', 'label_store',\\n 'description'],\\n summarize_labels=True)\\n\\n mit_bih_labels_str = ann.symbol\\n\\n labels_locations = ann.sample\\n\\n labels_description = ann.description\\n\\n return mit_bih_labels_str, labels_locations, labels_description\",\n \"def get_alignable_annotations(self, root):\\n\\n aas = root.findall(\\\".//ALIGNABLE_ANNOTATION\\\")\\n return {aa.attrib[\\\"ANNOTATION_ID\\\"]: aa for aa in aas}\",\n \"def _used_annotations(cls) -> set:\\n return set(field.type for field in dataclasses.fields(cls))\",\n \"def extract_annotations(self, min_annot=3):\\n for g in self.games:\\n annotation_list = [move.strip(\\\"{}\\\") for move in g.moves if move.strip().startswith(\\\"{\\\")]\\n if len(annotation_list) < min_annot:\\n continue\\n\\n annotation = \\\" \\\".join(annotation_list)\\n self.annotations.append(annotation)\",\n \"def get_overview_annotations() -> dict:\\n return {}\",\n \"def audit_annotations(self) -> Optional[Sequence['outputs.AuditAnnotation']]:\\n return pulumi.get(self, \\\"audit_annotations\\\")\",\n \"def _load_annotations(self):\\n if self._raw_annotations is not None:\\n return self._raw_annotations\\n\\n dataset_file = os.path.join(self._annotation_path, 'complete_dataset_v{}.pkl'.format(self._version))\\n idx_file = os.path.join(self._annotation_path, 'splits_indices_v{}.pkl'.format(self._version))\\n\\n def get_split_from_ds(ds, idx):\\n split = {}\\n keys = sorted(ds.keys())\\n for j in xrange(len(idx)):\\n k = keys[idx[j]]\\n split[k] = ds[k]\\n return split\\n\\n with open(idx_file, 'rb') as fid:\\n indices = cPickle.load(fid)[self._image_set]\\n with open(dataset_file, 'rb') as fid:\\n ds = cPickle.load(fid)\\n self._raw_annotations = get_split_from_ds(ds, indices)\\n\\n return self._raw_annotations\",\n \"def get_annotations(xmlsent):\\n annotations = []\\n annotation_elements = xmlsent.findall(\\\".//{%s}a\\\" % NS)\\n for element in annotation_elements:\\n annotation = {}\\n annotation['type'] = element.attrib.get('type')\\n annotation['flavor'] = element.attrib.get('flavor')\\n annotation['who'] = element.attrib.get('who')\\n annotation['text'] = element.text\\n annot = {'type': element.attrib.get('type'), 'flavor': element.attrib.get('flavor'), \\n 'who': element.attrib.get('who'), 'text': element.text}\\n annotations.append(annot)\\n return annotations\",\n \"def all_annotation_fns(self):\\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]\",\n \"def audit_annotations(self) -> Optional[Sequence['outputs.AuditAnnotationPatch']]:\\n return pulumi.get(self, \\\"audit_annotations\\\")\",\n \"def load_annotations(self, index):\\n anns_file = open(os.path.join(self.folder_path, self.image_ids[index] + '.json'))\\n labels = json.load(anns_file)\\n labels = labels[\\\"shapes\\\"]\\n anns_file.close()\\n return labels.copy()\",\n \"def annotations(self, annotations):\\n self._annotations = annotations\",\n \"def getAnnotation(self, *args):\\n return _libsbml.SBase_getAnnotation(self, *args)\",\n \"def inspect_ann(node):\\n if node.annotation is not None:\\n return [{\\\"name\\\": \\\"annotation\\\", \\\"line\\\": node.annotation.lineno - 1, \\\"end_line\\\": node.annotation.end_lineno - 1,\\n \\\"col_offset\\\": node.annotation.col_offset, \\\"end_col_offset\\\": node.annotation.end_col_offset,\\n \\\"var_line\\\": node.lineno - 1, \\\"var_end_line\\\": node.end_lineno - 1, \\\"var_col_offset\\\": node.col_offset,\\n \\\"var_end_col_offset\\\": node.end_col_offset}]\\n else:\\n return []\",\n \"def needsAnnotationsDictionary(self):\\n return self.needs_annotations_dict\",\n \"def _get_annotations(self, node, offset_mngr):\\n for anno in self._iterfind(node, 'annotation'):\\n offsets = list(self._get_offsets(anno, offset_mngr))\\n yield self._entity(anno, offsets)\",\n \"def _load_annotations(self):\\n annotation_file = self._filepath(self.ANNOTATION_FILE)\\n with open(annotation_file) as f:\\n json_data = json.load(f)\\n\\n return json_data\",\n \"def get_annotation_names(viewer):\\n\\n layer_nodes_name = None\\n layer_edges_name = None\\n for layer in viewer.layers:\\n if isinstance(layer, napari.layers.points.points.Points):\\n layer_nodes_name = layer.name\\n elif isinstance(layer, napari.layers.shapes.shapes.Shapes):\\n layer_edges_name = layer.name\\n if layer_nodes_name is not None and layer_edges_name is not None:\\n break\\n return layer_nodes_name, layer_edges_name\",\n \"def get_analysis_annotations():\\n sample_id = demisto.getArg('id')\\n r = req('GET', SUB_API + 'samples/' + sample_id + '/analysis/annotations')\\n\\n annotations = []\\n context_path = 'ThreatGrid.AnalysisResults.Sample.Id.Annotations'\\n ec = {context_path: []} # type: ignore\\n ips = demisto.get(r.json(), 'data.items.network') # type: ignore\\n if ips:\\n for k in ips:\\n annotation = {\\n 'IP': k,\\n 'IP.Asn': ips[k].get('asn'),\\n 'IP.City': ips[k].get('city'),\\n 'IP.Country': ips[k].get('country'),\\n 'IP.Org': ips[k].get('org'),\\n 'IP.Region': ips[k].get('region'),\\n 'IP.Timestamp': ips[k].get('ts')\\n }\\n annotations.append(annotation)\\n ec[context_path].append(annotation)\\n\\n demisto.results({\\n 'Type': entryTypes['note'],\\n 'ContentsFormat': formats['json'],\\n 'Contents': r.json(),\\n 'EntryContext': ec,\\n 'HumanReadable': tableToMarkdown('ThreatGrid - Analysis Annotations', annotations, [\\n 'IP', 'IP.Asn', 'IP.City', 'IP.Country', 'IP.Org', 'IP.Region', 'IP.Timestamp'\\n ])\\n })\",\n \"def get_filtered_dataset_annotations(config):\\n\\n images_filenames = net.data.get_dataset_filenames(\\n config[\\\"voc\\\"][\\\"data_directory\\\"], config[\\\"voc\\\"][\\\"validation_set_path\\\"])\\n\\n annotations_paths = [os.path.join(config[\\\"voc\\\"][\\\"data_directory\\\"], \\\"Annotations\\\", image_filename + \\\".xml\\\")\\n for image_filename in images_filenames]\\n\\n labels_to_categories_index_map = {label: index for (index, label) in enumerate(config[\\\"categories\\\"])}\\n\\n all_annotations = []\\n\\n for annotations_path in tqdm.tqdm(annotations_paths):\\n\\n with open(annotations_path) as file:\\n\\n image_annotations_xml = xmltodict.parse(file.read())\\n\\n image_size = \\\\\\n int(image_annotations_xml[\\\"annotation\\\"][\\\"size\\\"][\\\"height\\\"]), \\\\\\n int(image_annotations_xml[\\\"annotation\\\"][\\\"size\\\"][\\\"width\\\"])\\n\\n # Read annotations\\n annotations = net.data.get_objects_annotations(\\n image_annotations=image_annotations_xml,\\n labels_to_categories_index_map=labels_to_categories_index_map)\\n\\n # Resize annotations in line with how we would resize the image\\n annotations = [annotation.resize(image_size, config[\\\"size_factor\\\"]) for annotation in annotations]\\n\\n # Discard odd sized annotations\\n annotations = \\\\\\n [annotation for annotation in annotations\\n if not net.utilities.is_annotation_size_unusual(annotation, **config[\\\"objects_filtering\\\"])]\\n\\n all_annotations.extend(annotations)\\n\\n return all_annotations\",\n \"def _get_annotation(self, image_id):\\n annotation_file = self.image_sets_dir / f'{image_id}.xml'\\n objects = ET.parse(annotation_file).findall('object')\\n boxes = []\\n labels = []\\n is_difficult = []\\n for obj in objects:\\n class_name = obj.find('name').text.lower().strip()\\n if class_name in self.class_dict:\\n bbox = obj.find('bndbox')\\n\\n x0 = float(bbox.find('xmin').text) - 1\\n y0 = float(bbox.find('ymin').text) - 1\\n x1 = float(bbox.find('xmax').text) - 1\\n y1 = float(bbox.find('ymax').text) - 1\\n boxes.append([x0, y0, x1, y1])\\n\\n labels.append(self.class_dict[class_name])\\n\\n is_difficult_str = obj.find('difficult').text\\n is_difficult.append(int(is_difficult_str) if is_difficult_str else 0)\\n\\n return (np.array(boxes, dtype=np.float32),\\n np.array(labels, dtype=np.int64),\\n np.array(is_difficult, dtype=np.uint8))\",\n \"def annotations(self):\\n annotations = {\\\"date\\\": self.date_trunc(\\\"usage_start\\\")}\\n # { query_param: database_field_name }\\n fields = self._mapper.provider_map.get(\\\"annotations\\\")\\n for q_param, db_field in fields.items():\\n annotations[q_param] = F(db_field)\\n if (\\n \\\"project\\\" in self.parameters.parameters.get(\\\"group_by\\\", {})\\n or \\\"and:project\\\" in self.parameters.parameters.get(\\\"group_by\\\", {})\\n or \\\"or:project\\\" in self.parameters.parameters.get(\\\"group_by\\\", {})\\n ):\\n annotations[\\\"project\\\"] = F(\\\"namespace\\\")\\n\\n return annotations\",\n \"def annotation(self):\\n return (self._name, self._value)\",\n \"def load_annotations(self):\\n if self.ann_file.endswith('.json'):\\n return self.load_json_annotations()\\n\\n video_infos = []\\n with open(self.ann_file, 'r') as fin:\\n for line in fin:\\n line_split = line.strip().split()\\n if self.multi_class:\\n assert self.num_classes is not None\\n filename, label = line_split[0], line_split[1:]\\n label = list(map(int, label))\\n else:\\n filename, label = line_split\\n label = int(label)\\n if self.data_prefix is not None:\\n filename = osp.join(self.data_prefix, filename)\\n video_infos.append(dict(filename=filename, label=label))\\n while len(video_infos) < self.min_video_num:\\n left_num = min(self.min_video_num - len(video_infos), len(video_infos))\\n video_infos.extend(random.sample(video_infos, left_num))\\n return video_infos\",\n \"def get_labels(self) -> Set[str]:\",\n \"def count_annotation_values(graph, annotation):\\n return Counter(iter_annotation_values(graph, annotation))\",\n \"def annotations_per_batch(self):\\n if self._batch_size is None or self.task in {'objdet', 'sggen'}:\\n return self._annotations_per_batch\\n annos_per_img = self._annos_per_img[self.dataset]\\n if self.task in {'predcls', 'sgcls'}:\\n annos_per_img = annos_per_img['pairs']\\n elif self.task == 'objcls':\\n annos_per_img = annos_per_img['objects']\\n elif self.task == 'preddet' and self.filter_multiple_preds:\\n annos_per_img = annos_per_img['predicates_filtered']\\n elif self.task == 'preddet' and self.filter_duplicate_rels:\\n annos_per_img = annos_per_img['duplicates_filtered']\\n elif self.task == 'preddet':\\n annos_per_img = annos_per_img['relations']\\n return annos_per_img * self._batch_size\",\n \"def entities(self):\\n if 'ner' not in self.annotators:\\n return None\\n return [t[self.NER] for t in self.data]\",\n \"def entities(self):\\n if 'ner' not in self.annotators:\\n return None\\n return [t[self.NER] for t in self.data]\",\n \"def type_hint_annotations(self) -> list[FakeAnnotation]:\\n result: list[FakeAnnotation] = []\\n for child in self.children:\\n if child.type_annotation.get_local_types():\\n result.append(child.type_annotation)\\n return result\",\n \"def get_aliens(self):\\n return self._aliens\",\n \"def generate_annotations(self, caching=CachingType.NONE):\\n # Make the nltk Text list of words\\n text = self.nltk_text(self.text)\\n\\n # Get the uncommon_words\\n uncommon_words = self.eliminate_common(text)\\n # Get the places / VIPs / hystorical events / etc.\\n extras = self.get_extras(text)\\n # Generate the annotations\\n annotations = []\\n for word in uncommon_words:\\n ann = annot.TextAnnotation(word, AnnotationType.UNCOMMON_WORD,\\n caching)\\n ann.save_to_db()\\n if ann.data is None or not ann.data:\\n continue\\n annotations.append(ann)\\n for word in extras:\\n ann = annot.TextAnnotation(word, AnnotationType.EXTRA, caching)\\n ann.save_to_db(case_sensitive=True)\\n if ann.data is None or not ann.data:\\n continue\\n annotations.append(ann)\\n # Return the list of annotations\\n return annotations\",\n \"def extract_annotations(chosen_classes, annotations_dir, dataset_dir, val_set, train_set): \\n extension = ''\\n annotations_train = []\\n annotations_val = []\\n class_names = set()\\n for xml_file in [f for f in os.listdir(annotations_dir) if f.endswith(\\\".xml\\\")]:\\n tree = ET.parse(os.path.join(annotations_dir, xml_file))\\n root = tree.getroot()\\n file_name = None\\n image = xml_file[:-3] \\n try: \\n extension = [image_file for image_file in os.listdir(dataset_dir) if image_file.split('.')[0]==image[:-1]][0].split('.')[1]\\n \\n if os.path.exists(dataset_dir + image+extension):\\n for elem in root:\\n if elem.tag == 'filename':\\n file_name = os.path.join(dataset_dir, image+extension)\\n if elem.tag == 'object':\\n obj_name = None\\n coords = []\\n for subelem in elem:\\n if subelem.tag == 'name':\\n obj_name = subelem.text \\n if subelem.tag == 'bndbox':\\n for subsubelem in subelem:\\n coords.append(subsubelem.text)\\n item = [file_name] + coords + [obj_name]\\n if obj_name in chosen_classes:\\n class_names.add(obj_name)\\n if xml_file in val_set:\\n annotations_val.append(item)\\n elif xml_file in train_set:\\n annotations_train.append(item)\\n except:\\n print(\\\"Image file for xml with name: \\\", xml_file, \\\" does not seem to exist!\\\")\\n return annotations_train, annotations_val, class_names\",\n \"def encode_annotations(self, documents:List[Document]):\\n\\n # Loop over documents\\n labels = []\\n for doc in documents:\\n # Loop over sentences\\n label_index =[]\\n for sentence in doc.sentences:\\n #Loop over tokens\\n for token in sentence.tokens:\\n #convert label to numerical representation\\n label_index.append(self.labels2index[token.label])\\n\\n labels.append(label_index)\\n\\n return labels\",\n \"def _parse_anno_info(self, annotations):\\n gt_bboxes, gt_bboxes_ignore = [], []\\n gt_masks, gt_masks_ignore = [], []\\n gt_labels = []\\n for ann in annotations:\\n if ann.get('iscrowd', False):\\n gt_bboxes_ignore.append(ann['bbox'])\\n gt_masks_ignore.append(ann.get('segmentation', None))\\n else:\\n gt_bboxes.append(ann['bbox'])\\n gt_labels.append(ann['category_id'])\\n gt_masks.append(ann.get('segmentation', None))\\n if gt_bboxes:\\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\\n gt_labels = np.array(gt_labels, dtype=np.int64)\\n else:\\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\\n gt_labels = np.array([], dtype=np.int64)\\n\\n if gt_bboxes_ignore:\\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\\n else:\\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\\n\\n ann = dict(\\n bboxes=gt_bboxes,\\n labels=gt_labels,\\n bboxes_ignore=gt_bboxes_ignore,\\n masks_ignore=gt_masks_ignore,\\n masks=gt_masks)\\n\\n return ann\",\n \"def _init_annotation(self):\\n annotations = []\\n for frame in self.frames:\\n coordinates, sources, targets, ids = [], [], [], []\\n frame_id = set()\\n for spot_id, spot_annot in frame.items():\\n coordinates.append((spot_annot[\\\"x\\\"], spot_annot[\\\"y\\\"]))\\n sources.append(spot_annot[\\\"source\\\"])\\n targets.append(spot_annot[\\\"target\\\"])\\n ids.append(spot_id)\\n frame_id.add(spot_annot[\\\"frame\\\"])\\n if len(frame_id) != 1:\\n raise ValueError(f\\\"Invalid frame number found in spot: {spot_id}\\\")\\n annotations.append((\\n np.array(coordinates, dtype=np.float),\\n np.array(sources, dtype=np.str),\\n targets,\\n np.array(ids, dtype=np.str),\\n frame_id.pop()))\\n self.annotations = annotations\",\n \"def load_annos(self):\\n data = None\\n with open(self.anno_path, 'r') as file:\\n if self.ext == '.json':\\n data = json.load(file)\\n\\n # Label start at index 0\\n if data is not None:\\n for anno in data['annotations']:\\n anno['category_id'] -= 1\\n\\n for anno in data['categories']:\\n anno['id'] -= 1\\n\\n return data\",\n \"def metric_annotations_allow_list(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"metric_annotations_allow_list\\\")\",\n \"def _get_annotation(cls, name):\\n return cls.__annotations__.get(name)\",\n \"def get_annotation_gene_types(args):\\n ref_mgr = ReferenceManager(args.reference_path)\\n tss = BedTool(ref_mgr.tss_track)\\n if tss.field_count() == 7:\\n return TRANSCRIPT_ANNOTATION_GENE_TYPES\\n else:\\n return None\",\n \"def getAnnotationString(self, *args):\\n return _libsbml.SBase_getAnnotationString(self, *args)\",\n \"def Markers(cls):\\n return cls._markers\",\n \"def __resolve_annotation_conflicts(self, annotations):\\n # set the bounding box and initial positions of the annotations\\n # the x-value is only corrected if it is inside the graph or too close to the graph\\n left = []\\n right = []\\n for a in annotations:\\n # first, get the bounds\\n self.__set_annotation_bbox(a)\\n\\n # now set the intitial positions\\n # we want all of the text to be on the left or right of the squares\\n width = a.bbox.width\\n # to preserve hint values, only set the x value if it is inside the graph\\n # or if it is not at least as far as the offset\\n if a.y >= 0 and a.y <= self.ymax:\\n if ((a.x >= self.xmax / 2) and (a.x < self.xmax)) or (a.x >= self.xmax and a.x < self.xmax + self.settings.otherParams[\\\"annotation.right.offset\\\"]):\\n a.x = self.xmax + \\\\\\n self.settings.otherParams[\\\"annotation.right.offset\\\"]\\n elif ((a.x >= 0) and (a.x < self.xmax / 2)) or (a.x <= self.xmin and a.x > self.xmin - self.settings.otherParams[\\\"annotation.left.offset\\\"]):\\n a.x = self.xmin - \\\\\\n self.settings.otherParams[\\\"annotation.left.offset\\\"] - width\\n a.bbox.x0 = a.x\\n a.bbox.x1 = a.x + width\\n if (a.x >= self.xmax / 2):\\n a.set_relpos((0, 0.5))\\n right.append(a)\\n if (a.x < self.xmax / 2):\\n a.set_relpos((1, 0.5))\\n left.append(a)\\n elif a.y < 0:\\n a.set_relpos((0.5, 0))\\n right.append(a)\\n elif a.y > self.ymax:\\n a.set_relpos((0.5, 1))\\n right.append(a)\\n\\n # for the left, we want to prioritze labels\\n # with lower x values to minimize the crossover of annotation lines\\n # for the right, we want to prioritize labels that are closer\\n # to the right side of the graph to minimuze the crossover of annotation lines\\n left.sort(key=lambda a: (a.event_point.y, a.event_point.x))\\n right.sort(key=lambda a: (a.event_point.y, -a.event_point.x))\\n\\n final = []\\n for lst in [left, right]:\\n _f = []\\n for unchecked in lst:\\n for checked in _f:\\n if unchecked.overlaps(checked):\\n correction = unchecked.get_xy_correction(\\n checked, self.label_space_epsilon)\\n unchecked.update_Y_with_correction(correction)\\n if unchecked.is_within_epsilon_of(checked, self.label_space_epsilon):\\n correction = [0, self.label_space_epsilon]\\n unchecked.update_Y_with_correction(correction)\\n _f.append(unchecked)\\n final.extend(_f)\\n\\n return final\",\n \"def get_unused_list_annotation_values(graph):\\n result = {}\\n for annotation, values in graph.annotation_list.items():\\n used_values = get_annotation_values(graph, annotation)\\n if len(used_values) == len(values): # all values have been used\\n continue\\n result[annotation] = set(values) - used_values\\n return result\",\n \"def get_all_anns(filepaths):\\n annotations = []\\n for filepath in filepaths:\\n with open(filepath, 'r') as f:\\n for line in f:\\n ent = line.split('\\\\t')[0].strip()\\n tag = line.split('\\\\t')[-1].strip()\\n # get rid of newlines\\n if ent != '' and tag != '':\\n annotations.append((ent, tag))\\n\\n return annotations\",\n \"def get_annotations_for_person(self, person_id: int) -> np.ndarray:\\n return self._get_annotations_for_person_or_pose(person_id, np.array(['personAIK']))\",\n \"def dump_annotations(self):\\n fname = 'annotations'\\n if self.split is not None:\\n fname = 'annotations_{}'.format(self.split)\\n fname = os.path.join(self.dest_folder, '{}.json'.format(fname))\\n self.save(self.dataset, fname, \\\"annotations\\\")\",\n \"def get_annotation_dataframe(self):\\n return pd.DataFrame(self.annotation_line_list)\",\n \"def get_annotation_object(annots_path):\\n\\n lines = annots_path.read_text().split('\\\\n')\\n \\n annots = []\\n for line in lines:\\n if not line:\\n continue\\n \\n annot = {}\\n splot = line.split(' ')\\n annot['class_id'] = int(splot[0])\\n annot['center_x'] = float(splot[1])\\n annot['center_y'] = float(splot[2])\\n annot['width'] = float(splot[3])\\n annot['height'] = float(splot[4])\\n annot['class_name'] = splot[-1]\\n \\n if splot[5].startswith('px:'):\\n px = splot[5].strip('px:')\\n py = splot[6].strip('py:')\\n \\n if not (px == 'auto'):\\n px = px.split(',')\\n py = py.split(',')\\n annot['px'] = [float(x) for x in px]\\n annot['py'] = [float(x) for x in py]\\n else:\\n annot['px'] = 'auto'\\n annot['py'] = 'auto'\\n \\n elif splot[5].startswith('conf:'):\\n annot['conf'] = float(splot[5].split(':')[1])\\n\\n annots.append(annot)\\n \\n return annots\",\n \"def get_annotations(self, table_name: str, annotation_ids: List[int]) -> List[dict]:\\n schema_type, AnnotationModel = self._load_model(table_name)\\n\\n annotations = (\\n self.db.cached_session.query(AnnotationModel)\\n .filter(AnnotationModel.id.in_(list(annotation_ids)))\\n .all()\\n )\\n\\n anno_schema, __ = self.schema.split_flattened_schema(schema_type)\\n schema = anno_schema(unknown=INCLUDE)\\n try:\\n data = []\\n\\n for anno in annotations:\\n anno_data = anno.__dict__\\n anno_data[\\\"created\\\"] = str(anno_data.get(\\\"created\\\"))\\n anno_data[\\\"deleted\\\"] = str(anno_data.get(\\\"deleted\\\"))\\n anno_data = {\\n k: v for (k, v) in anno_data.items() if k != \\\"_sa_instance_state\\\"\\n }\\n data.append(anno_data)\\n\\n return schema.load(data, many=True)\\n\\n except Exception as e:\\n logging.exception(e)\\n raise NoAnnotationsFoundWithID(annotation_ids) from e\",\n \"def annotate_images(self) -> Union[int, None]:\\n if not self.ann or not self.ns:\\n logging.warning(\\\"Missing annotation or namespace, \\\"\\n \\\"skipping annotations\\\")\\n return None\\n if self.image_ids:\\n if len(self.image_ids) == 0:\\n logging.error('No image ids to annotate')\\n return None\\n else:\\n map_ann_id = multi_post_map_annotation(self.conn, \\\"Image\\\",\\n self.image_ids,\\n self.ann,\\n self.ns)\\n return map_ann_id\\n return None\",\n \"def load_annotations(path):\\n annotations = joblib.load(path);\\n return annotations\",\n \"def get_annotation_list(\\n self,\\n project_id: int,\\n doc_id: int\\n ) -> requests.models.Response:\\n return self.get(\\n 'v1/projects/{project_id}/docs/{doc_id}/annotations'.format(\\n project_id=project_id,\\n doc_id=doc_id\\n )\\n )\",\n \"def _get_annotations(self, text, language=''):\\n body = {\\n 'document': {\\n 'type': 'PLAIN_TEXT',\\n 'content': text,\\n },\\n 'features': {\\n 'extract_syntax': True,\\n },\\n 'encodingType': 'UTF32',\\n }\\n if language:\\n body['document']['language'] = language\\n\\n request = self.service.documents().annotateText(body=body)\\n response = request.execute()\\n tokens = response.get('tokens', [])\\n language = response.get('language')\\n\\n return {'tokens': tokens, 'language': language}\",\n \"def _get_ann_file(self):\\n prefix = 'instances' if 'test' not in self.image_set else 'image_info'\\n return os.path.join(self.data_path, 'annotations',\\n prefix + '_' + self.image_set + '.json')\",\n \"def labels_all(self):\\n return self._labels_all\",\n \"def annotation(self, ann_type: str = None):\\n if ann_type is None: ann_type = self.ann\\n if ann_type != self.ann:\\n warnings.warn('Please note that the annotation type is mismatch with the dataset setting!')\\n\\n if ann_type == 'label':\\n xml_path = self.xml_path.format(id=self.id)\\n ann = int(ET.parse(xml_path).find('defective').text)\\n elif ann_type == 'bbox':\\n xml_path = self.xml_path.format(id=self.id)\\n objs = ET.parse(xml_path).findall('bbox')\\n ann = []\\n for ix, bbox in enumerate(objs):\\n y1 = int(float(bbox.find('ymin').text))\\n y2 = int(float(bbox.find('ymax').text))\\n x1 = int(float(bbox.find('xmin').text))\\n x2 = int(float(bbox.find('xmax').text))\\n ann.append((y1, y2, x1, x2))\\n elif ann_type == 'mask':\\n mask_path = self.mask_path.format(id=self.id)\\n if os.path.exists(mask_path):\\n ann = Image.open(mask_path).convert('L')\\n else:\\n ann = Image.fromarray(np.zeros((512, 512), dtype=np.uint8)).convert('L')\\n elif ann_type == 'none':\\n ann = []\\n else:\\n raise NotImplementedError\\n return ann\",\n \"def get_annotations(data_folder):\\n annotations_files = os.listdir('data_annotations')\\n\\n annotations = {}\\n for file_name in annotations_files:\\n annotation = json.load(\\n open(f'{data_folder}/annotations/{file_name}', 'r')\\n )\\n key = int(annotation['entity_id'])\\n annotations[key] = annotation['value']['value']\\n\\n return annotations\",\n \"def to_standoff(self):\\n tidx, nidx = 1, 1\\n all_anns = []\\n for a in self.annotations:\\n anns = a.to_standoff(tidx, nidx)\\n all_anns.extend(anns)\\n nidx += len(anns)-1 # all but one are norms\\n tidx += 1\\n return all_anns\",\n \"def GetAnnotations(args, messages):\\n annotations = getattr(args, 'annotations', {})\\n additional_property_messages = []\\n if not annotations:\\n return None\\n\\n for key, value in annotations.items():\\n additional_property_messages.append(\\n messages.V2Key.AnnotationsValue.AdditionalProperty(\\n key=key, value=value))\\n\\n annotation_value_message = messages.V2Key.AnnotationsValue(\\n additionalProperties=additional_property_messages)\\n\\n return annotation_value_message\",\n \"def graphs(self):\\n return self.__graphs\",\n \"def get_annotated_lines(self):\\n lines = [Line(idx + 1, x) for idx, x in enumerate(self.sourcelines)]\\n\\n try:\\n lines[self.lineno - 1].current = True\\n except IndexError:\\n pass\\n\\n return lines\",\n \"def load_annotations(self):\\n # get keys\\n with open(self.ann_file, 'r') as fin:\\n keys = [line.strip().split(' ')[0] for line in fin]\\n # get frame index list for LQ frames\\n frame_index_list = []\\n for i in range(self.num_input_frames):\\n # Each clip of Vimeo90K has 7 frames starting from 1. So we use 9\\n # for generating frame_index_list:\\n # N | frame_index_list\\n # 1 | 4\\n # 3 | 3,4,5\\n # 5 | 2,3,4,5,6\\n # 7 | 1,2,3,4,5,6,7\\n frame_index_list.append(i + (9 - self.num_input_frames) // 2)\\n\\n data_infos = []\\n for key in keys:\\n folder, subfolder = key.split('/')\\n lq_paths = []\\n for i in frame_index_list:\\n lq_paths.append(\\n osp.join(self.lq_folder, folder, subfolder, f'im{i}.png'))\\n gt_paths = [osp.join(self.gt_folder, folder, subfolder, 'im4.png')]\\n\\n data_infos.append(\\n dict(lq_path=lq_paths, gt_path=gt_paths, key=key))\\n\\n return data_infos\",\n \"def ListAnnotations(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def annotations(self, annotations):\\n if annotations is None:\\n raise ValueError(\\\"Invalid value for `annotations`, must not be `None`\\\") # noqa: E501\\n\\n self._annotations = annotations\",\n \"def select_annotations(\\n self, center_x: int, center_y: int, width: int, height: int\\n ) -> List[Annotation]:\\n\\n box = geometry.box(\\n center_x - width // 2,\\n center_y - height // 2,\\n center_x + width // 2,\\n center_y + height // 2,\\n )\\n\\n annotations = [\\n self._annotations[pos] for pos in self._tree.intersection(box.bounds)\\n ]\\n\\n for sorter in self._sorters:\\n annotations = sorter(annotations)\\n return annotations\",\n \"def _is_annotated(nodes: List[Node]):\\n annotated = False\\n for node in nodes:\\n annotated = annotated or (\\n \\\"quantization_annotation\\\" in node.meta\\n and node.meta[\\\"quantization_annotation\\\"]._annotated\\n )\\n return annotated\",\n \"def save_annotations(self):\\n r = requests.get(\\n f'{self.api_host}/v1/entity-annotations?'\\n f'annotation_type=Source reliability (binary)&size=100',\\n headers=self.get_request_headers()\\n )\\n\\n entity_annotations = r.json().get('entity_annotations')\\n\\n for annotation in entity_annotations:\\n annotation_id = annotation.get('entity_id')\\n with open(\\n f'{self.data_folder}/annotations/{annotation_id}.json',\\n 'w'\\n ) as f:\\n json.dump(annotation, f)\",\n \"def getMarkerGenes(self):\\n try:\\n self.marker_genes = Utils.findMarkers(self.sc_annot, self.de_dict)\\n except:\\n print(\\\"Please run getCellTypes first to get cell annotations. This step is needed for marker gene finding.\\\")\",\n \"def markers (self):\\n return self._markers\",\n \"def get_labels(self):\\n return []\",\n \"def notifiers(self):\\n return self.registry.keys()\",\n \"def _convert_annotations(self, ast):\\n self.annotations = IDLAnnotations(ast)\",\n \"def get_annotations(tag_repository):\\n timeml_tags = (EVENT, TIMEX, ALINK, SLINK, TLINK)\\n annotations = { tagname: {} for tagname in timeml_tags }\\n event_idx = {}\\n timex_idx = {}\\n for tag in tag_repository.all_tags():\\n if tag.name == EVENT:\\n event_idx[tag.attrs[EIID]] = tag\\n elif tag.name == TIMEX:\\n timex_idx[tag.attrs[TID]] = tag\\n for tag in tag_repository.all_tags():\\n if tag.name in timeml_tags:\\n offsets = get_offsets(tag, event_idx, timex_idx)\\n if offsets is not None:\\n annotations[tag.name][offsets] = tag.attrs\\n return annotations\",\n \"def getNumSemanticsAnnotations(self):\\n return _libsbml.ASTNode_getNumSemanticsAnnotations(self)\",\n \"def load_annotations(self, image_index):\\n\\t\\t\\t# Get ground truth annotations.\\n\\t\\t\\tannotations_ids = self.coco.getAnnIds(imgIds=self.image_ids[image_index], iscrowd=False)\\n\\t\\t\\tannotations = {'labels': np.empty((0,)), 'bboxes': np.empty((0, 4))}\\n\\n\\t\\t\\t# If needed get info for masks.\\n\\t\\t\\tif self.mask:\\n\\t\\t\\t\\timport cv2\\n\\n\\t\\t\\t\\t# Get image info.\\n\\t\\t\\t\\timage_info = self.coco.loadImgs(self.image_ids[image_index])[0]\\n\\t\\t\\t\\tannotations['masks'] = []\\n\\n\\t\\t\\t# Some images appear to miss annotations (like image with id 257034).\\n\\t\\t\\tif len(annotations_ids) == 0:\\n\\t\\t\\t\\treturn annotations\\n\\n\\n\\t\\t\\t# Parse annotations\\n\\t\\t\\tcoco_annotations = self.coco.loadAnns(annotations_ids)\\n\\t\\t\\tfor idx, a in enumerate(coco_annotations):\\n\\t\\t\\t\\t# Some annotations have basically no width / height, skip them.\\n\\t\\t\\t\\tif a['bbox'][2] < 1 or a['bbox'][3] < 1:\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\tannotations['labels'] = np.concatenate([annotations['labels'], [self.coco_label_to_label(a['category_id'])]], axis=0)\\n\\t\\t\\t\\tannotations['bboxes'] = np.concatenate([annotations['bboxes'], [[\\n\\t\\t\\t\\t\\ta['bbox'][0],\\n\\t\\t\\t\\t\\ta['bbox'][1],\\n\\t\\t\\t\\t\\ta['bbox'][0] + a['bbox'][2],\\n\\t\\t\\t\\t\\ta['bbox'][1] + a['bbox'][3],\\n\\t\\t\\t\\t]]], axis=0)\\n\\n\\t\\t\\t\\t# If needed get annotations for masks.\\n\\t\\t\\t\\tif self.mask:\\n\\t\\t\\t\\t\\tif 'segmentation' not in a:\\n\\t\\t\\t\\t\\t\\traise ValueError('Expected \\\\'segmentation\\\\' key in annotation, got: {}'.format(a))\\n\\n\\t\\t\\t\\t\\tmask = np.zeros((image_info['height'], image_info['width'], 1), dtype=np.uint8)\\n\\t\\t\\t\\t\\tfor seg in a['segmentation']:\\n\\t\\t\\t\\t\\t\\tpoints = np.array(seg).reshape((len(seg) // 2, 2)).astype(int)\\n\\n\\t\\t\\t\\t\\t\\t# Draw mask.\\n\\t\\t\\t\\t\\t\\tcv2.fillPoly(mask, [points.astype(int)], (1,))\\n\\n\\t\\t\\t\\t\\tannotations['masks'].append(mask.astype(float))\\n\\n\\n\\t\\t\\treturn annotations\",\n \"def get_document_annotations(document_id, include_extractions=False, session=konfuzio_session()):\\n url = get_document_api_details_url(document_id, include_extractions=include_extractions)\\n r = retry_get(session, url)\\n annotations = r.json()['annotations']\\n not_custom_annotations = annotations\\n revised_annotations_and_extractions = [\\n x for x in not_custom_annotations if x['revised'] or x['is_correct'] or not x['id']\\n ]\\n sorted_annotations = sorted(\\n revised_annotations_and_extractions, key=lambda x: (x.get('start_offset') is None, x.get('start_offset'))\\n )\\n logger.info(f'Document with ID {document_id} contains {len(sorted_annotations)} annotations.')\\n\\n return sorted_annotations\",\n \"def load_annotations(self, image_index):\\n filename = self.image_names[image_index] + '.xml'\\n try:\\n tree = ET.parse(os.path.join(self.data_dir, 'Annotations', filename))\\n return self.__parse_annotations(tree.getroot())\\n except ET.ParseError as e:\\n raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)\\n except ValueError as e:\\n raise_from(ValueError('invalid annotations file: {}: {}'.format(filename, e)), None)\",\n \"def overlap(annotations1, annotations2):\\n return [val for val in annotations1 if val in annotations2]\",\n \"def define_annotation_list(y_pos, bgcolor, text, colorfont, name, hovertext):\\n return dict(\\n x = -0,\\n y = y_pos,\\n xanchor = 'left',\\n text = text,\\n hovertext = hovertext,\\n showarrow = False,\\n captureevents = True,\\n bgcolor = bgcolor,\\n font = { 'size' : 12, 'color' : colorfont },\\n height = 14\\n )\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8111795","0.8045864","0.7362889","0.7362889","0.7331711","0.70147973","0.69533426","0.69257975","0.69232273","0.69228804","0.68237376","0.6820551","0.6820551","0.67251045","0.6618748","0.6587142","0.65761614","0.652672","0.6499983","0.6469789","0.633797","0.63091135","0.6214065","0.6190084","0.6026786","0.6002573","0.5992932","0.5984607","0.59333974","0.59197986","0.59139025","0.591243","0.58989704","0.5895654","0.58730346","0.5826198","0.5801234","0.57383287","0.5731881","0.57202667","0.57007957","0.56945986","0.5692542","0.56724894","0.56651545","0.56646365","0.5631732","0.56094664","0.56094664","0.56020606","0.5588064","0.55866116","0.55491203","0.5523997","0.5520229","0.5512843","0.55091673","0.55080825","0.5491652","0.54882467","0.548565","0.5479777","0.5478847","0.5476289","0.5468582","0.5468489","0.5468325","0.54566455","0.5441028","0.5423759","0.54162055","0.54002506","0.5399514","0.539691","0.53927463","0.5388562","0.5382353","0.5378898","0.53774035","0.53651273","0.5361649","0.5354918","0.5346675","0.5341459","0.53350896","0.53115654","0.5310131","0.5307614","0.5307242","0.53068686","0.5303572","0.5291583","0.5287738","0.5282318","0.52738583","0.5273715","0.5269764","0.52660185","0.52509713","0.52472585"],"string":"[\n \"0.8111795\",\n \"0.8045864\",\n \"0.7362889\",\n \"0.7362889\",\n \"0.7331711\",\n \"0.70147973\",\n \"0.69533426\",\n \"0.69257975\",\n \"0.69232273\",\n \"0.69228804\",\n \"0.68237376\",\n \"0.6820551\",\n \"0.6820551\",\n \"0.67251045\",\n \"0.6618748\",\n \"0.6587142\",\n \"0.65761614\",\n \"0.652672\",\n \"0.6499983\",\n \"0.6469789\",\n \"0.633797\",\n \"0.63091135\",\n \"0.6214065\",\n \"0.6190084\",\n \"0.6026786\",\n \"0.6002573\",\n \"0.5992932\",\n \"0.5984607\",\n \"0.59333974\",\n \"0.59197986\",\n \"0.59139025\",\n \"0.591243\",\n \"0.58989704\",\n \"0.5895654\",\n \"0.58730346\",\n \"0.5826198\",\n \"0.5801234\",\n \"0.57383287\",\n \"0.5731881\",\n \"0.57202667\",\n \"0.57007957\",\n \"0.56945986\",\n \"0.5692542\",\n \"0.56724894\",\n \"0.56651545\",\n \"0.56646365\",\n \"0.5631732\",\n \"0.56094664\",\n \"0.56094664\",\n \"0.56020606\",\n \"0.5588064\",\n \"0.55866116\",\n \"0.55491203\",\n \"0.5523997\",\n \"0.5520229\",\n \"0.5512843\",\n \"0.55091673\",\n \"0.55080825\",\n \"0.5491652\",\n \"0.54882467\",\n \"0.548565\",\n \"0.5479777\",\n \"0.5478847\",\n \"0.5476289\",\n \"0.5468582\",\n \"0.5468489\",\n \"0.5468325\",\n \"0.54566455\",\n \"0.5441028\",\n \"0.5423759\",\n \"0.54162055\",\n \"0.54002506\",\n \"0.5399514\",\n \"0.539691\",\n \"0.53927463\",\n \"0.5388562\",\n \"0.5382353\",\n \"0.5378898\",\n \"0.53774035\",\n \"0.53651273\",\n \"0.5361649\",\n \"0.5354918\",\n \"0.5346675\",\n \"0.5341459\",\n \"0.53350896\",\n \"0.53115654\",\n \"0.5310131\",\n \"0.5307614\",\n \"0.5307242\",\n \"0.53068686\",\n \"0.5303572\",\n \"0.5291583\",\n \"0.5287738\",\n \"0.5282318\",\n \"0.52738583\",\n \"0.5273715\",\n \"0.5269764\",\n \"0.52660185\",\n \"0.52509713\",\n \"0.52472585\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.8332945"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20161,"cells":{"query":{"kind":"string","value":"Gets the set of all annotations that are defined in a graph, but are never used."},"document":{"kind":"string","value":"def get_unused_annotations(graph):\n return graph.defined_annotation_keywords - get_annotations(graph)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_annotations(graph):\n return set(_annotation_iter_helper(graph))","def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))","def get_unused_list_annotation_values(graph):\n result = {}\n for annotation, values in graph.annotation_list.items():\n used_values = get_annotation_values(graph, annotation)\n if len(used_values) == len(values): # all values have been used\n continue\n result[annotation] = set(values) - used_values\n return result","def _used_annotations(cls) -> set:\n return set(field.type for field in dataclasses.fields(cls))","def _annotation_iter_helper(graph):\n return (\n key\n for _, _, data in graph.edges(data=True)\n if ANNOTATIONS in data\n for key in data[ANNOTATIONS]\n )","def annotations(self):\n return self._annotations","def annotations(self):\n\n return self._annotations","def annotations(self) -> Iterator['Annotation']:\n return itertools.chain(self.footnotecitations.all(),\n self.cites.all(),\n self.externallinks.all(),\n self.inlinerequirements.all())","def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def GetAnnotationsQS(self):\n return self._costly_annotations_qs","def get_naked_names(graph: BELGraph) -> Set[str]:\n return set(_naked_names_iter(graph))","def GetQNoAnnotations(cls):\n return models.Q(annotationstable__isnull=True)","def eligible_nodes(self):\n return [v for v in self.G if self.eligible_node(v)]","def annotations(self):\n\t\tif self._record is not None:\n\t\t return self._record.annotations\n\t\telse:\n\t\t return {}","def likely_regressions(self):\n return set([label for label, count in self.regressions.items() if count == 0])","def needsAnnotationsDictionary(self):\n return self.needs_annotations_dict","def __get_ids_of_all_unrelaxed_candidates__(self):\n\n all_unrelaxed_ids = set([t.gaid for t in self.c.select(relaxed=0)])\n all_relaxed_ids = set([t.gaid for t in self.c.select(relaxed=1)])\n all_queued_ids = set([t.gaid for t in self.c.select(queued=1)])\n\n actually_unrelaxed = [gaid for gaid in all_unrelaxed_ids\n if (gaid not in all_relaxed_ids and\n gaid not in all_queued_ids)]\n\n return actually_unrelaxed","def tags_used(self):\n return set([query.all_referenced_tags for query in self.snippets])","def GetRequiredNamespaces(self):\n return set(self._required_namespaces)","def ind_nodes(self, graph=None):\n if graph is None:\n graph = self.graph\n\n dependent_nodes = set(\n node for dependents in graph.values() for node in dependents\n )\n return [node for node in graph.keys() if node not in dependent_nodes]","def reset_annotations(self):\n # FIXME: this state does not make sense\n self.annotation_date_set = False\n self.annotation_comment_set = False\n self.annotation_type_set = False\n self.annotation_spdx_id_set = False","def infoboxes_of_graph(self):\n infoboxes = []\n for nodeName in super(SynonymNetwork, self).nodes():\n infoboxes = infoboxes + self.infoboxes_of_graph_node(nodeName)\n return list(set(infoboxes))","def GetProvidedNamespaces(self):\n return set(self._provided_namespaces)","def GetMissingRequires(self):\n external_dependencies = set(self._required_namespaces)\n\n # Assume goog namespace is always available.\n external_dependencies.add('goog')\n # goog.module is treated as a builtin, too (for goog.module.get).\n external_dependencies.add('goog.module')\n\n created_identifiers = set()\n for unused_namespace, identifier, unused_line_number in (\n self._created_namespaces):\n created_identifiers.add(identifier)\n\n missing_requires = dict()\n illegal_alias_statements = dict()\n\n def ShouldRequireNamespace(namespace, identifier):\n \"\"\"Checks if a namespace would normally be required.\"\"\"\n return (\n not self._IsPrivateIdentifier(identifier) and\n namespace not in external_dependencies and\n namespace not in self._provided_namespaces and\n identifier not in external_dependencies and\n identifier not in created_identifiers and\n namespace not in missing_requires)\n\n # First check all the used identifiers where we know that their namespace\n # needs to be provided (unless they are optional).\n for ns in self._used_namespaces:\n namespace = ns.namespace\n identifier = ns.identifier\n if (not ns.alias_definition and\n ShouldRequireNamespace(namespace, identifier)):\n missing_requires[namespace] = ns.GetLine()\n\n # Now that all required namespaces are known, we can check if the alias\n # definitions (that are likely being used for typeannotations that don't\n # need explicit goog.require statements) are already covered. If not\n # the user shouldn't use the alias.\n for ns in self._used_namespaces:\n if (not ns.alias_definition or\n not ShouldRequireNamespace(ns.namespace, ns.identifier)):\n continue\n if self._FindNamespace(ns.identifier, self._provided_namespaces,\n created_identifiers, external_dependencies,\n missing_requires):\n continue\n namespace = ns.identifier.rsplit('.', 1)[0]\n illegal_alias_statements[namespace] = ns.token\n\n return missing_requires, illegal_alias_statements","def referencedNamespaces (self):\n return frozenset(self.__referencedNamespaces)","def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\n return pulumi.get(self, \"annotations\")","def excluded(cls):\n return []","def fully_hidden_arrays(self):\n hidden = []\n for m in self.masks():\n invalid = self.get_property(m, '_no_valid_items')\n if invalid: hidden.append(m)\n return hidden","def all_leaves(self, graph=None):\n if graph is None:\n graph = self.graph\n return [key for key in graph if not graph[key]]","def excludes(self):\r\n\r\n return self._excludes","def _get_corner_annotations_visibility(self) :\n \n return self._corner_annotations_visibility","def available_sets(session, player):\n excluded_sets = set(session.taken.keys())\n for grouping in session.exclusives:\n if player.sets.intersection(grouping):\n excluded_sets.update(grouping)\n return [s for s in session.sets if s not in excluded_sets]","def importedNamespaces (self):\n return frozenset(self.__importedNamespaces)","def list_all(self):\n if self.graph is None:\n self.logger.error(\"Graph value none cannot be iterated\")\n return list()\n\n nodes = list()\n for node in self.graph.nodes():\n if node == self.NONE_PACKAGE:\n continue\n nodes.append(node)\n return nodes","def possible_regressions(self):\n return set([label for label, count in self.regressions.items() if count > 0])","def get_edges(self):\n return \\\n set({\n edge\n for node in self.nodeset\n for edge in node.get_incident_edges()\n })","def type_hint_annotations(self) -> list[FakeAnnotation]:\n result: list[FakeAnnotation] = []\n for child in self.children:\n if child.type_annotation.get_local_types():\n result.append(child.type_annotation)\n return result","def _all_edges(node: FMVGraphNode) -> Set[FMVGraphEdge]:\n rval = set([e for e in node.edges\n if e.predicate not in skip_fhir_predicates and e.type_node.node not in skip_fhir_types])\n for p in node.parents:\n if p.node not in skip_fhir_types:\n rval.update(FHIROntologyTable._all_edges(p))\n return rval","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def test_inspect_dont_show_annotations(tmp_path):\n matplotlib = pytest.importorskip(\"matplotlib\")\n import matplotlib.pyplot as plt\n\n matplotlib.use(\"Agg\")\n plt.close(\"all\")\n\n bids_root = setup_bids_test_dir(tmp_path)\n bids_path = _bids_path.copy().update(root=bids_root)\n inspect_dataset(bids_path, find_flat=False, show_annotations=False)\n raw_fig = mne_bids.inspect._global_vars[\"raw_fig\"]\n assert not raw_fig.mne.annotations","def edges_without_adjacencies(self):\n edges = dict(self.eligible_edges_with_indexes)\n for adj in self.adjacencies.values():\n for edge_info in adj:\n if edge_info.self_edge_index in edges:\n edges[edge_info.self_edge_index] = None\n return list(filter(lambda x: x is not None, edges.values()))","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def nodes(self):\n nodes = []\n for key, val in self._graph.items():\n nodes.append(key)\n nodes.extend([v for v in val.keys() if v not in nodes])\n return set(nodes)","def not_processed(self) -> Set[str]:\n return set(self._source.find(rf'.*')) - self._processed","def independent_nodes(self):\n dependent_nodes = set(node for dependents in self.graph.values()\n for node in dependents)\n return [node for node in self.graph.keys()\n if node not in dependent_nodes]","def excludes(self) -> Set:\n if self._excludes is None:\n manifest = self._get_manifest()\n self._excludes = manifest[\"files\"][\"excludes\"]\n\n return self._excludes","def missing_variables(self):\n return [k for k in self.all_variables if k not in self._properties]","def contained(self):\n seen = set()\n return [l.to_segment for l in self.edges_to_contained \\\n if id(l) not in seen and not seen.add(id(l))]","def _unresolvedDependents (self):\n return self.__unresolvedDependents","def find_isolated_vertices(self):\n graph = self.__graph_dict\n isolated = []\n for vertex in graph:\n # print(isolated,vertex)\n if not graph[vertex]:\n isolated += [vertex]\n return isolated","def all_annotation_fns(self):\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]","def get_all_associations(self):\n return","def ignores(self):\n return self._ignores","def eligible_edges(self):\n return self.edges","def get_nullable_symbols(self) -> AbstractSet[CFGObject]:\n if self._nullable_symbols is None:\n self._nullable_symbols = self._get_generating_or_nullable(True)\n return self._nullable_symbols","def missing_mappings(self):\n return [ mapping for mapping in self.mapping_names() if not config.file_in_cache(self.name, self.observatory) ]","def graphs(self):\n return self.__graphs","def excluded_from_scan(self):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/excludedFromScan/')))","def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))","def nodes(self):\n return set(self.values())","def isomorphism_representatives(self):\n result = set()\n for c in self:\n cc = c.relabel()\n if cc not in result:\n result.add(cc)\n return result","def unusedVars(self):\n fullcode = self.code_cfg\n variables = set([x[1:] for x in codeconfig_getvars(fullcode)])\n exceptions = set(['complexity', 'code_cfg'])\n clsvars = set(vars(self).keys())\n nones = set(filter(lambda x: self.__dict__[x] is None, clsvars))\n nones = nones.union(set(filter(lambda x: str(self.__dict__[x]) == \"\", clsvars)))\n unused = clsvars - variables - exceptions - nones\n return unused","def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\n annotations = []\n for item in self.collector:\n data_file_type = os.path.basename(item).split(\".\")[-1]\n annotations.append(\n load_annotation_file(\n os.path.join(\n self.annotation_folder,\n os.path.basename(item).replace(data_file_type, \"json\"),\n )\n )\n )\n\n return annotations","def all(self):\r\n return self.attr_dict.keys()","def all_genes_in_dataset(self):\n # the empty-set argument is needed in case there are no mutants in the dataset - set.union() with empty args is an error.\n return set.union(set(), *[set(genes) for N_mutants,genes \n in self.dataset.get_gene_dict_by_mutant_number(self.dataset_name).items() if N_mutants>0])","def GetMissingProvides(self):\n missing_provides = dict()\n for namespace, identifier, line_number in self._created_namespaces:\n if (not self._IsPrivateIdentifier(identifier) and\n namespace not in self._provided_namespaces and\n identifier not in self._provided_namespaces and\n namespace not in self._required_namespaces and\n namespace not in missing_provides):\n missing_provides[namespace] = line_number\n\n return missing_provides","def labels_all(self):\n return self._labels_all","def edgesWithVertices(self):\n\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}","def getMissingIds(self):\n return self._missingIds","def all_ids(self) -> Set[int]:\n return {node_id for _, (node_id, _) in self.nodes.items()}","def _annotations(request):\n result = Search(request).run(MultiDict(request.params))\n\n return request.find_service(AnnotationReadService).get_annotations_by_id(\n ids=result.annotation_ids\n )","def get_annotation_count(self):\n return self._num_annos","def missing_in_gn_by_file(self):\n return self._missing_gn_files","def known_safes(self):\n if self.count == 0:\n return self.cells\n return set([])","def attributes(self):\n attr = super(BaseDataRecord, self).attributes()\n return [a for a in attr if a not in self.excluded()]","def get_incident_edges(self):\n return set(self.incident_edges) # return the set of incident edges","def get_incident_edges(self):\n return set(self.incident_edges) # return the set of incident edges","def get_labels(self):\n return set(k.label for k in self)","def get_annotations(self):\n entity = self.get_object()\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\n return Response(serializer.data)","def get_all_metrics():\n return get_overlap_metrics() + get_distance_metrics() + get_distance_metrics()","def get_labels(self) -> Set[str]:","def extract_annotations(self, min_annot=3):\n for g in self.games:\n annotation_list = [move.strip(\"{}\") for move in g.moves if move.strip().startswith(\"{\")]\n if len(annotation_list) < min_annot:\n continue\n\n annotation = \" \".join(annotation_list)\n self.annotations.append(annotation)","def get_missing_genotypes(self):\n return utils.get_missing_genotypes(\n self.genotypes,\n mutations=self.mutations\n )","def markAsNeedsAnnotationsDictionary(self):\n self.needs_annotations_dict = True","def defined_tags(self):\n return self._defined_tags","def get_local_types(self) -> list[FakeAnnotation]:\n return [self]","def _find_inaccessible_workflows(self, prune_nodes):\n\n referrer_map = self._build_referrer_map()\n\n removed_referring_nodes = frozenset(\n node for referrers in referrer_map.values()\n for node in referrers\n if node in prune_nodes)\n\n return frozenset(\n workflow for (workflow, referrers) in six.iteritems(referrer_map)\n if all(referrer in removed_referring_nodes for referrer in referrers))","def nodes(self):\n\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))","def pruneMarks(self):\n self.__prune_marks(self.nodes(data=True))","def essential_node_kinds(self) -> Set[str]:\n return {\n n.kind()\n for n in self.graph.nodes()\n if n.kind() not in self._EXCLUDED_NODE_KINDS\n }","def empty(self):\n return _osgAnimation.mapVertexInfluence_empty(self)","def get_unlabelled_tweets_reannotation():\n conn = get_connection()\n c = conn.cursor()\n #res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression is null AND tweets.username IN (SELECT username FROM users WHERE mentions_depr=1)').fetchall()\n res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression IN (0, 1, 2) AND tweets.is_about_depression2 IS NULL ORDER BY random()').fetchall()\n conn.close()\n return np.array(res)","def notifiers(self):\n return self.registry.keys()","def getNotMyCamps(self):\n r = []\n for p in self.__camps:\n if(p.getOwner() != 1):\n r.append(p)\n return r","def missing(self):\n return tuple([f for f in self._required \\\n if f not in self or self[f] == None])","def get_conflicts(self):\n return []","def get_alignable_annotations(self, root):\n\n aas = root.findall(\".//ALIGNABLE_ANNOTATION\")\n return {aa.attrib[\"ANNOTATION_ID\"]: aa for aa in aas}","def not_reachable(self,graph):\n reachable_in = nx.descendants(graph, 0)\n reachable_out = nx.ancestors(graph, self.nodes - 1)\n # add the last node back in\n reachable_out.add(self.nodes - 1)\n\n set_of_nodes = set(range(1, self.nodes))\n\n not_reachable_in = set_of_nodes - reachable_in\n not_reachable_out = set_of_nodes - reachable_out\n return not_reachable_in ,not_reachable_out"],"string":"[\n \"def get_annotations(graph):\\n return set(_annotation_iter_helper(graph))\",\n \"def get_annotation_values(graph, annotation):\\n return set(iter_annotation_values(graph, annotation))\",\n \"def get_unused_list_annotation_values(graph):\\n result = {}\\n for annotation, values in graph.annotation_list.items():\\n used_values = get_annotation_values(graph, annotation)\\n if len(used_values) == len(values): # all values have been used\\n continue\\n result[annotation] = set(values) - used_values\\n return result\",\n \"def _used_annotations(cls) -> set:\\n return set(field.type for field in dataclasses.fields(cls))\",\n \"def _annotation_iter_helper(graph):\\n return (\\n key\\n for _, _, data in graph.edges(data=True)\\n if ANNOTATIONS in data\\n for key in data[ANNOTATIONS]\\n )\",\n \"def annotations(self):\\n return self._annotations\",\n \"def annotations(self):\\n\\n return self._annotations\",\n \"def annotations(self) -> Iterator['Annotation']:\\n return itertools.chain(self.footnotecitations.all(),\\n self.cites.all(),\\n self.externallinks.all(),\\n self.inlinerequirements.all())\",\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def GetAnnotationsQS(self):\\n return self._costly_annotations_qs\",\n \"def get_naked_names(graph: BELGraph) -> Set[str]:\\n return set(_naked_names_iter(graph))\",\n \"def GetQNoAnnotations(cls):\\n return models.Q(annotationstable__isnull=True)\",\n \"def eligible_nodes(self):\\n return [v for v in self.G if self.eligible_node(v)]\",\n \"def annotations(self):\\n\\t\\tif self._record is not None:\\n\\t\\t return self._record.annotations\\n\\t\\telse:\\n\\t\\t return {}\",\n \"def likely_regressions(self):\\n return set([label for label, count in self.regressions.items() if count == 0])\",\n \"def needsAnnotationsDictionary(self):\\n return self.needs_annotations_dict\",\n \"def __get_ids_of_all_unrelaxed_candidates__(self):\\n\\n all_unrelaxed_ids = set([t.gaid for t in self.c.select(relaxed=0)])\\n all_relaxed_ids = set([t.gaid for t in self.c.select(relaxed=1)])\\n all_queued_ids = set([t.gaid for t in self.c.select(queued=1)])\\n\\n actually_unrelaxed = [gaid for gaid in all_unrelaxed_ids\\n if (gaid not in all_relaxed_ids and\\n gaid not in all_queued_ids)]\\n\\n return actually_unrelaxed\",\n \"def tags_used(self):\\n return set([query.all_referenced_tags for query in self.snippets])\",\n \"def GetRequiredNamespaces(self):\\n return set(self._required_namespaces)\",\n \"def ind_nodes(self, graph=None):\\n if graph is None:\\n graph = self.graph\\n\\n dependent_nodes = set(\\n node for dependents in graph.values() for node in dependents\\n )\\n return [node for node in graph.keys() if node not in dependent_nodes]\",\n \"def reset_annotations(self):\\n # FIXME: this state does not make sense\\n self.annotation_date_set = False\\n self.annotation_comment_set = False\\n self.annotation_type_set = False\\n self.annotation_spdx_id_set = False\",\n \"def infoboxes_of_graph(self):\\n infoboxes = []\\n for nodeName in super(SynonymNetwork, self).nodes():\\n infoboxes = infoboxes + self.infoboxes_of_graph_node(nodeName)\\n return list(set(infoboxes))\",\n \"def GetProvidedNamespaces(self):\\n return set(self._provided_namespaces)\",\n \"def GetMissingRequires(self):\\n external_dependencies = set(self._required_namespaces)\\n\\n # Assume goog namespace is always available.\\n external_dependencies.add('goog')\\n # goog.module is treated as a builtin, too (for goog.module.get).\\n external_dependencies.add('goog.module')\\n\\n created_identifiers = set()\\n for unused_namespace, identifier, unused_line_number in (\\n self._created_namespaces):\\n created_identifiers.add(identifier)\\n\\n missing_requires = dict()\\n illegal_alias_statements = dict()\\n\\n def ShouldRequireNamespace(namespace, identifier):\\n \\\"\\\"\\\"Checks if a namespace would normally be required.\\\"\\\"\\\"\\n return (\\n not self._IsPrivateIdentifier(identifier) and\\n namespace not in external_dependencies and\\n namespace not in self._provided_namespaces and\\n identifier not in external_dependencies and\\n identifier not in created_identifiers and\\n namespace not in missing_requires)\\n\\n # First check all the used identifiers where we know that their namespace\\n # needs to be provided (unless they are optional).\\n for ns in self._used_namespaces:\\n namespace = ns.namespace\\n identifier = ns.identifier\\n if (not ns.alias_definition and\\n ShouldRequireNamespace(namespace, identifier)):\\n missing_requires[namespace] = ns.GetLine()\\n\\n # Now that all required namespaces are known, we can check if the alias\\n # definitions (that are likely being used for typeannotations that don't\\n # need explicit goog.require statements) are already covered. If not\\n # the user shouldn't use the alias.\\n for ns in self._used_namespaces:\\n if (not ns.alias_definition or\\n not ShouldRequireNamespace(ns.namespace, ns.identifier)):\\n continue\\n if self._FindNamespace(ns.identifier, self._provided_namespaces,\\n created_identifiers, external_dependencies,\\n missing_requires):\\n continue\\n namespace = ns.identifier.rsplit('.', 1)[0]\\n illegal_alias_statements[namespace] = ns.token\\n\\n return missing_requires, illegal_alias_statements\",\n \"def referencedNamespaces (self):\\n return frozenset(self.__referencedNamespaces)\",\n \"def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def excluded(cls):\\n return []\",\n \"def fully_hidden_arrays(self):\\n hidden = []\\n for m in self.masks():\\n invalid = self.get_property(m, '_no_valid_items')\\n if invalid: hidden.append(m)\\n return hidden\",\n \"def all_leaves(self, graph=None):\\n if graph is None:\\n graph = self.graph\\n return [key for key in graph if not graph[key]]\",\n \"def excludes(self):\\r\\n\\r\\n return self._excludes\",\n \"def _get_corner_annotations_visibility(self) :\\n \\n return self._corner_annotations_visibility\",\n \"def available_sets(session, player):\\n excluded_sets = set(session.taken.keys())\\n for grouping in session.exclusives:\\n if player.sets.intersection(grouping):\\n excluded_sets.update(grouping)\\n return [s for s in session.sets if s not in excluded_sets]\",\n \"def importedNamespaces (self):\\n return frozenset(self.__importedNamespaces)\",\n \"def list_all(self):\\n if self.graph is None:\\n self.logger.error(\\\"Graph value none cannot be iterated\\\")\\n return list()\\n\\n nodes = list()\\n for node in self.graph.nodes():\\n if node == self.NONE_PACKAGE:\\n continue\\n nodes.append(node)\\n return nodes\",\n \"def possible_regressions(self):\\n return set([label for label, count in self.regressions.items() if count > 0])\",\n \"def get_edges(self):\\n return \\\\\\n set({\\n edge\\n for node in self.nodeset\\n for edge in node.get_incident_edges()\\n })\",\n \"def type_hint_annotations(self) -> list[FakeAnnotation]:\\n result: list[FakeAnnotation] = []\\n for child in self.children:\\n if child.type_annotation.get_local_types():\\n result.append(child.type_annotation)\\n return result\",\n \"def _all_edges(node: FMVGraphNode) -> Set[FMVGraphEdge]:\\n rval = set([e for e in node.edges\\n if e.predicate not in skip_fhir_predicates and e.type_node.node not in skip_fhir_types])\\n for p in node.parents:\\n if p.node not in skip_fhir_types:\\n rval.update(FHIROntologyTable._all_edges(p))\\n return rval\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def test_inspect_dont_show_annotations(tmp_path):\\n matplotlib = pytest.importorskip(\\\"matplotlib\\\")\\n import matplotlib.pyplot as plt\\n\\n matplotlib.use(\\\"Agg\\\")\\n plt.close(\\\"all\\\")\\n\\n bids_root = setup_bids_test_dir(tmp_path)\\n bids_path = _bids_path.copy().update(root=bids_root)\\n inspect_dataset(bids_path, find_flat=False, show_annotations=False)\\n raw_fig = mne_bids.inspect._global_vars[\\\"raw_fig\\\"]\\n assert not raw_fig.mne.annotations\",\n \"def edges_without_adjacencies(self):\\n edges = dict(self.eligible_edges_with_indexes)\\n for adj in self.adjacencies.values():\\n for edge_info in adj:\\n if edge_info.self_edge_index in edges:\\n edges[edge_info.self_edge_index] = None\\n return list(filter(lambda x: x is not None, edges.values()))\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def nodes(self):\\n nodes = []\\n for key, val in self._graph.items():\\n nodes.append(key)\\n nodes.extend([v for v in val.keys() if v not in nodes])\\n return set(nodes)\",\n \"def not_processed(self) -> Set[str]:\\n return set(self._source.find(rf'.*')) - self._processed\",\n \"def independent_nodes(self):\\n dependent_nodes = set(node for dependents in self.graph.values()\\n for node in dependents)\\n return [node for node in self.graph.keys()\\n if node not in dependent_nodes]\",\n \"def excludes(self) -> Set:\\n if self._excludes is None:\\n manifest = self._get_manifest()\\n self._excludes = manifest[\\\"files\\\"][\\\"excludes\\\"]\\n\\n return self._excludes\",\n \"def missing_variables(self):\\n return [k for k in self.all_variables if k not in self._properties]\",\n \"def contained(self):\\n seen = set()\\n return [l.to_segment for l in self.edges_to_contained \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\n \"def _unresolvedDependents (self):\\n return self.__unresolvedDependents\",\n \"def find_isolated_vertices(self):\\n graph = self.__graph_dict\\n isolated = []\\n for vertex in graph:\\n # print(isolated,vertex)\\n if not graph[vertex]:\\n isolated += [vertex]\\n return isolated\",\n \"def all_annotation_fns(self):\\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]\",\n \"def get_all_associations(self):\\n return\",\n \"def ignores(self):\\n return self._ignores\",\n \"def eligible_edges(self):\\n return self.edges\",\n \"def get_nullable_symbols(self) -> AbstractSet[CFGObject]:\\n if self._nullable_symbols is None:\\n self._nullable_symbols = self._get_generating_or_nullable(True)\\n return self._nullable_symbols\",\n \"def missing_mappings(self):\\n return [ mapping for mapping in self.mapping_names() if not config.file_in_cache(self.name, self.observatory) ]\",\n \"def graphs(self):\\n return self.__graphs\",\n \"def excluded_from_scan(self):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/excludedFromScan/')))\",\n \"def count_annotation_values(graph, annotation):\\n return Counter(iter_annotation_values(graph, annotation))\",\n \"def nodes(self):\\n return set(self.values())\",\n \"def isomorphism_representatives(self):\\n result = set()\\n for c in self:\\n cc = c.relabel()\\n if cc not in result:\\n result.add(cc)\\n return result\",\n \"def unusedVars(self):\\n fullcode = self.code_cfg\\n variables = set([x[1:] for x in codeconfig_getvars(fullcode)])\\n exceptions = set(['complexity', 'code_cfg'])\\n clsvars = set(vars(self).keys())\\n nones = set(filter(lambda x: self.__dict__[x] is None, clsvars))\\n nones = nones.union(set(filter(lambda x: str(self.__dict__[x]) == \\\"\\\", clsvars)))\\n unused = clsvars - variables - exceptions - nones\\n return unused\",\n \"def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\\n annotations = []\\n for item in self.collector:\\n data_file_type = os.path.basename(item).split(\\\".\\\")[-1]\\n annotations.append(\\n load_annotation_file(\\n os.path.join(\\n self.annotation_folder,\\n os.path.basename(item).replace(data_file_type, \\\"json\\\"),\\n )\\n )\\n )\\n\\n return annotations\",\n \"def all(self):\\r\\n return self.attr_dict.keys()\",\n \"def all_genes_in_dataset(self):\\n # the empty-set argument is needed in case there are no mutants in the dataset - set.union() with empty args is an error.\\n return set.union(set(), *[set(genes) for N_mutants,genes \\n in self.dataset.get_gene_dict_by_mutant_number(self.dataset_name).items() if N_mutants>0])\",\n \"def GetMissingProvides(self):\\n missing_provides = dict()\\n for namespace, identifier, line_number in self._created_namespaces:\\n if (not self._IsPrivateIdentifier(identifier) and\\n namespace not in self._provided_namespaces and\\n identifier not in self._provided_namespaces and\\n namespace not in self._required_namespaces and\\n namespace not in missing_provides):\\n missing_provides[namespace] = line_number\\n\\n return missing_provides\",\n \"def labels_all(self):\\n return self._labels_all\",\n \"def edgesWithVertices(self):\\n\\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}\",\n \"def getMissingIds(self):\\n return self._missingIds\",\n \"def all_ids(self) -> Set[int]:\\n return {node_id for _, (node_id, _) in self.nodes.items()}\",\n \"def _annotations(request):\\n result = Search(request).run(MultiDict(request.params))\\n\\n return request.find_service(AnnotationReadService).get_annotations_by_id(\\n ids=result.annotation_ids\\n )\",\n \"def get_annotation_count(self):\\n return self._num_annos\",\n \"def missing_in_gn_by_file(self):\\n return self._missing_gn_files\",\n \"def known_safes(self):\\n if self.count == 0:\\n return self.cells\\n return set([])\",\n \"def attributes(self):\\n attr = super(BaseDataRecord, self).attributes()\\n return [a for a in attr if a not in self.excluded()]\",\n \"def get_incident_edges(self):\\n return set(self.incident_edges) # return the set of incident edges\",\n \"def get_incident_edges(self):\\n return set(self.incident_edges) # return the set of incident edges\",\n \"def get_labels(self):\\n return set(k.label for k in self)\",\n \"def get_annotations(self):\\n entity = self.get_object()\\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\\n return Response(serializer.data)\",\n \"def get_all_metrics():\\n return get_overlap_metrics() + get_distance_metrics() + get_distance_metrics()\",\n \"def get_labels(self) -> Set[str]:\",\n \"def extract_annotations(self, min_annot=3):\\n for g in self.games:\\n annotation_list = [move.strip(\\\"{}\\\") for move in g.moves if move.strip().startswith(\\\"{\\\")]\\n if len(annotation_list) < min_annot:\\n continue\\n\\n annotation = \\\" \\\".join(annotation_list)\\n self.annotations.append(annotation)\",\n \"def get_missing_genotypes(self):\\n return utils.get_missing_genotypes(\\n self.genotypes,\\n mutations=self.mutations\\n )\",\n \"def markAsNeedsAnnotationsDictionary(self):\\n self.needs_annotations_dict = True\",\n \"def defined_tags(self):\\n return self._defined_tags\",\n \"def get_local_types(self) -> list[FakeAnnotation]:\\n return [self]\",\n \"def _find_inaccessible_workflows(self, prune_nodes):\\n\\n referrer_map = self._build_referrer_map()\\n\\n removed_referring_nodes = frozenset(\\n node for referrers in referrer_map.values()\\n for node in referrers\\n if node in prune_nodes)\\n\\n return frozenset(\\n workflow for (workflow, referrers) in six.iteritems(referrer_map)\\n if all(referrer in removed_referring_nodes for referrer in referrers))\",\n \"def nodes(self):\\n\\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))\",\n \"def pruneMarks(self):\\n self.__prune_marks(self.nodes(data=True))\",\n \"def essential_node_kinds(self) -> Set[str]:\\n return {\\n n.kind()\\n for n in self.graph.nodes()\\n if n.kind() not in self._EXCLUDED_NODE_KINDS\\n }\",\n \"def empty(self):\\n return _osgAnimation.mapVertexInfluence_empty(self)\",\n \"def get_unlabelled_tweets_reannotation():\\n conn = get_connection()\\n c = conn.cursor()\\n #res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression is null AND tweets.username IN (SELECT username FROM users WHERE mentions_depr=1)').fetchall()\\n res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression IN (0, 1, 2) AND tweets.is_about_depression2 IS NULL ORDER BY random()').fetchall()\\n conn.close()\\n return np.array(res)\",\n \"def notifiers(self):\\n return self.registry.keys()\",\n \"def getNotMyCamps(self):\\n r = []\\n for p in self.__camps:\\n if(p.getOwner() != 1):\\n r.append(p)\\n return r\",\n \"def missing(self):\\n return tuple([f for f in self._required \\\\\\n if f not in self or self[f] == None])\",\n \"def get_conflicts(self):\\n return []\",\n \"def get_alignable_annotations(self, root):\\n\\n aas = root.findall(\\\".//ALIGNABLE_ANNOTATION\\\")\\n return {aa.attrib[\\\"ANNOTATION_ID\\\"]: aa for aa in aas}\",\n \"def not_reachable(self,graph):\\n reachable_in = nx.descendants(graph, 0)\\n reachable_out = nx.ancestors(graph, self.nodes - 1)\\n # add the last node back in\\n reachable_out.add(self.nodes - 1)\\n\\n set_of_nodes = set(range(1, self.nodes))\\n\\n not_reachable_in = set_of_nodes - reachable_in\\n not_reachable_out = set_of_nodes - reachable_out\\n return not_reachable_in ,not_reachable_out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8046899","0.6747276","0.6727379","0.6385317","0.6370691","0.6229582","0.6198001","0.59983647","0.5742247","0.57196945","0.5694495","0.5674026","0.56460255","0.56373686","0.56286234","0.55884176","0.55659765","0.55608773","0.5503239","0.5494925","0.5482385","0.5464223","0.5454497","0.5441737","0.54344213","0.54050016","0.5356201","0.5329748","0.5328618","0.53178555","0.5314476","0.5307893","0.53020614","0.5296776","0.5285369","0.527783","0.5264892","0.5262829","0.52533203","0.52533203","0.52452695","0.5238859","0.52373385","0.52373385","0.52340794","0.5220172","0.51812613","0.51451224","0.51284105","0.5104471","0.5096212","0.5092443","0.50719523","0.50626117","0.50596833","0.50544924","0.50394064","0.5034243","0.5032682","0.50132453","0.50108457","0.5000607","0.4993025","0.49874943","0.49788463","0.49694481","0.49658924","0.4961319","0.4955963","0.4953796","0.49525216","0.4938723","0.49304748","0.4919319","0.4914289","0.4913048","0.49129632","0.49114588","0.49114588","0.49082714","0.490205","0.49000865","0.48896334","0.4889605","0.48836198","0.48797473","0.4877523","0.4868361","0.4865753","0.4860898","0.48525342","0.48522198","0.48487344","0.4843314","0.4842608","0.4840175","0.48400638","0.4839257","0.48321086","0.48311186"],"string":"[\n \"0.8046899\",\n \"0.6747276\",\n \"0.6727379\",\n \"0.6385317\",\n \"0.6370691\",\n \"0.6229582\",\n \"0.6198001\",\n \"0.59983647\",\n \"0.5742247\",\n \"0.57196945\",\n \"0.5694495\",\n \"0.5674026\",\n \"0.56460255\",\n \"0.56373686\",\n \"0.56286234\",\n \"0.55884176\",\n \"0.55659765\",\n \"0.55608773\",\n \"0.5503239\",\n \"0.5494925\",\n \"0.5482385\",\n \"0.5464223\",\n \"0.5454497\",\n \"0.5441737\",\n \"0.54344213\",\n \"0.54050016\",\n \"0.5356201\",\n \"0.5329748\",\n \"0.5328618\",\n \"0.53178555\",\n \"0.5314476\",\n \"0.5307893\",\n \"0.53020614\",\n \"0.5296776\",\n \"0.5285369\",\n \"0.527783\",\n \"0.5264892\",\n \"0.5262829\",\n \"0.52533203\",\n \"0.52533203\",\n \"0.52452695\",\n \"0.5238859\",\n \"0.52373385\",\n \"0.52373385\",\n \"0.52340794\",\n \"0.5220172\",\n \"0.51812613\",\n \"0.51451224\",\n \"0.51284105\",\n \"0.5104471\",\n \"0.5096212\",\n \"0.5092443\",\n \"0.50719523\",\n \"0.50626117\",\n \"0.50596833\",\n \"0.50544924\",\n \"0.50394064\",\n \"0.5034243\",\n \"0.5032682\",\n \"0.50132453\",\n \"0.50108457\",\n \"0.5000607\",\n \"0.4993025\",\n \"0.49874943\",\n \"0.49788463\",\n \"0.49694481\",\n \"0.49658924\",\n \"0.4961319\",\n \"0.4955963\",\n \"0.4953796\",\n \"0.49525216\",\n \"0.4938723\",\n \"0.49304748\",\n \"0.4919319\",\n \"0.4914289\",\n \"0.4913048\",\n \"0.49129632\",\n \"0.49114588\",\n \"0.49114588\",\n \"0.49082714\",\n \"0.490205\",\n \"0.49000865\",\n \"0.48896334\",\n \"0.4889605\",\n \"0.48836198\",\n \"0.48797473\",\n \"0.4877523\",\n \"0.4868361\",\n \"0.4865753\",\n \"0.4860898\",\n \"0.48525342\",\n \"0.48522198\",\n \"0.48487344\",\n \"0.4843314\",\n \"0.4842608\",\n \"0.4840175\",\n \"0.48400638\",\n \"0.4839257\",\n \"0.48321086\",\n \"0.48311186\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.79468316"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20162,"cells":{"query":{"kind":"string","value":"Gets all of the unused values for list annotations"},"document":{"kind":"string","value":"def get_unused_list_annotation_values(graph):\n result = {}\n for annotation, values in graph.annotation_list.items():\n used_values = get_annotation_values(graph, annotation)\n if len(used_values) == len(values): # all values have been used\n continue\n result[annotation] = set(values) - used_values\n return result"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_unused_annotations(graph):\n return graph.defined_annotation_keywords - get_annotations(graph)","def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))","def metric_annotations_allow_list(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"metric_annotations_allow_list\")","def handle_enum(enum_annotations: Any) -> list:\n result = []\n for attribute in list(enum_annotations):\n result.append(attribute.value)\n return result","def variables_used (self) :\r\n\t\treturn [i[0] for i in self.parameters]","def unused_featurevalues():\n\n fvs = FeatureValue.objects.filter(feature__active=True)\n unused_fvs = fvs.filter(languages__isnull=True)\n natlang_only_fvs = fvs.filter(languages__language__natlang=True).exclude(languages__language__natlang=False)\n\n if not natlang_only_fvs:\n # Natlangs had no unique features so return early\n return unused_fvs\n\n # dsd\n decorate = ((fv.id, fv) for fv in set(unused_fvs) | set(natlang_only_fvs))\n sort = sorted(decorate)\n return [fv for (_, fv) in sort]","def get_misused_opt_arg_dec():\n return list(incompletely_used_decorators.values())","def list_value(self) -> global___Expression.RepeatedValue:","def get_annotations(graph):\n return set(_annotation_iter_helper(graph))","def values(self):\n return iter(util.annotate(v) for _, v in self._pairs())","def unusedVars(self):\n fullcode = self.code_cfg\n variables = set([x[1:] for x in codeconfig_getvars(fullcode)])\n exceptions = set(['complexity', 'code_cfg'])\n clsvars = set(vars(self).keys())\n nones = set(filter(lambda x: self.__dict__[x] is None, clsvars))\n nones = nones.union(set(filter(lambda x: str(self.__dict__[x]) == \"\", clsvars)))\n unused = clsvars - variables - exceptions - nones\n return unused","def get_values(self):\n \n return []","def get_attribute_list(self):\n attributes = [attr for attr in vars(self.entries[0]) if not attr.startswith('__')]\n return attributes","def _used_annotations(cls) -> set:\n return set(field.type for field in dataclasses.fields(cls))","def variables_used (self) :\r\n\t\treturn []","def used_yvals(self):\n return [y for y in self.yvals() if any([len(self.get_plaquette(x, y)) > 0\n for x in self.xvals()])]","def values(self) -> List:\n pass","def values(self):\n return [_ for _ in self._dict.values()]","def all_label_values(self, label_list_ids=None):\n values = set()\n\n for label_list in self.label_lists.values():\n if label_list_ids is None or label_list.idx in label_list_ids:\n values = values.union(label_list.label_values())\n\n return values","def _suppressions(self) -> List:\n sonar, sonar_id = self._metric_source, self._sonar_id()\n return [\n (sonar.false_positives(sonar_id), sonar.false_positives_url(sonar_id),\n \"Gemarkeerd als false positive in SonarQube\"),\n (sonar.wont_fix(sonar_id), sonar.wont_fix_url(sonar_id),\n \"Gemarkeerd als won't fix in SonarQube\"),\n (sonar.suppressions(sonar_id), sonar.suppressions_url(sonar_id),\n \"Gemarkeerd in de broncode met annotatie, commentaar (bijv. //NOSONAR) of pragma\")]","def annotation_filter(self,annotations):\n result = []\n for key,value in annotations.items():\n if key not in [Result.START_TIME,Result.END_TIME]:\n result.append((key,value))\n result.sort(key=operator.itemgetter(0))\n return result","def used_xvals(self):\n return [x for x in self.xvals() if any([len(self.get_plaquette(x, y)) > 0\n for y in self.yvals()])]","def extensible_attributes_list_values():\n return \"extensibleattributedef?\" \\\n \"_return_fields=\" \\\n \"list_values,\" \\\n \"comment,\" \\\n \"name,\" \\\n \"type\"","def get_all(cls, exclude_values: Iterator['CommonBusinessAdvertisingType'] = None) -> Tuple['CommonBusinessAdvertisingType']:\n if exclude_values is None:\n exclude_values = (cls.INVALID,)\n # noinspection PyTypeChecker\n value_list: Tuple[CommonBusinessAdvertisingType, ...] = tuple([value for value in cls.values if value not in exclude_values])\n return value_list","def get_values(self, names):\n r = []\n for n in names:\n if n in self.raw_metrics:\n r.append(self.raw_metrics[n])\n else:\n return None\n return r","def values(self):\n return [entry.value for entry in self.table if entry.value is not None]","def annotations(self):\n return self._annotations","def get_all(cls, exclude_values: Iterator['CommonBucksType'] = None) -> Tuple['CommonBucksType']:\n if exclude_values is None:\n exclude_values = (cls.INVALID,)\n # noinspection PyTypeChecker\n value_list: Tuple[CommonBucksType, ...] = tuple([value for value in cls.values if value not in exclude_values])\n return value_list","def get_list_of_present_entries(list_):\n\n _List = []\n for x in list_:\n if x not in _List:\n if not None:\n if not pd.isna(x):\n _List.append(x)\n return _List","def missing_variables(self):\n return [k for k in self.all_variables if k not in self._properties]","def list_missing_for_deposit(self, needs: Tuple) -> List[int]:\n missing = []\n for item in needs:\n if not any(self.needed_keywords_list(item)):\n missing.append(item)\n return missing","def all_values(cls) -> List[str]:\n return list(member.value for member in cls.__members__.values())","def _get_values(self) -> ty.List[float]:\r\n ...","def attributes(self):\n attr = super(BaseDataRecord, self).attributes()\n return [a for a in attr if a not in self.excluded()]","def ignored_lists(self) -> List[str]:\n return self.__lists_to_ignore","def listglobal(self):\n return list(self.attributes.keys())","def items(self) -> List[Tuple[str, float]]:\n return self._loss_dict.items()","def get_all(cls, exclude_values: Iterator['CommonGameTagCategory'] = None) -> Tuple['CommonGameTagCategory']:\n if exclude_values is None:\n exclude_values = (cls.INVALID,)\n # noinspection PyTypeChecker\n value_list: Tuple[CommonGameTagCategory, ...] = tuple([value for value in cls.values if value not in exclude_values])\n return value_list","def excluded(cls):\n return []","def exclude_list(self):\n pass","def _more_properties_blacklist(self) -> List[str]:\n return []","def fully_hidden_arrays(self):\n hidden = []\n for m in self.masks():\n invalid = self.get_property(m, '_no_valid_items')\n if invalid: hidden.append(m)\n return hidden","def getVariables(self):\n return [x for x in self.variables.values() if x is not None]","def values(self, annotated=False, as_list=False, separator='\\t'):\n if not self.attrs():\n return None\n if annotated:\n list_repr = [\"{}:{}\".format(attr, val) for attr, val in\n zip(self.__slots__, self._values(to_str=True))]\n else:\n list_repr = self._values(to_str=True)\n if as_list:\n return list_repr\n else:\n return separator.join(list_repr)","def unused_evals(self):\n\t\treturn self.Evals - self.nFES","def values(self):\n return [i.value for i in self.value]","def get_existing_values(self): #DONE\n return (value.value for value in self.address.values() if value.value)","def excluded_from_scan(self):\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/excludedFromScan/')))","def getStatusValues(self):\n return []","def annotations(self):\n\n return self._annotations","def get_all_variables(self):\n return []","def getVariableList(dataset):\n variables = [v for v in dataset.variables.keys() if v not in dataset.dimensions.keys()]\n for d in dataset.dimensions.keys():\n try:\n variables.pop(variables.index(dataset.variables[d].getncattr(\"bounds\")))\n except:\n pass\n return variables","def _get_vals(self, doc: Doc) -> Iterable[V]:\n raise NotImplementedError","def get_warning(self) -> List[str]:\n return []","def get_warning(self) -> List[str]:\n return []","def values():","def values(self):\n return self._list.values()","def get_all_blacklisted_as_list(self):\n try:\n result = self.table.select().execute()\n if result.rowcount >= 1:\n return [x.values() for x in result]\n elif result.rowcount == 0:\n return []\n except Exception as e:\n self.log(e, self.identifier)\n raise egg_errors.QueryNotPossible","def _build_parsed_values(self):\n # need to exclude sci times\n return self._parsed_values(GpsPositionDataParticle.keys_exclude_all_times)","def values(self):\n return self.attrs.values()","def get_all_variables(self):\n return [self.item]","def values(self):\n return [p.value for p in self]","def variables_used (self) :\r\n\t\t## These names do not contain dimension specification (everything in brackets\r\n\t\t## that comes after a name is am array index - either the arry was declared\r\n\t\t## correctly or it is wrong anyway, there is no implicit declaration of arrays) !\r\n\r\n\t\tresult = []\r\n\r\n\t\tfor l in self.equ_lists :\r\n\t\t\tfor var_name in l :\r\n\t\t\t\tresult.append(var_name[0])\r\n\t\treturn result","def get_marking_values():\n array = np.arange(0, MAX_MARK_VALUE +1).tolist()\n return array","def get_vlans_list(self):\n return self.vlans.keys()","def __listAttr(self):\n attr = dir(self) # already sorted\n filter = []\n for name in attr:\n if name[:2] == '__': pass\n elif name[:10] == '_HelpDoc__': pass # used to mask private attr\n elif name in self.__exclude: pass\n else: filter.append(name)\n return filter","def get_metric_variables(self) -> List[Any]:\n with self._lock:\n return self._get_metric_variables()","def values(self):\n return [getattr(self, a.name) for a in self.__attrs_attrs__]","def getMetadataList(self):\n return [ x.toTuple() for x in self.metadata ]","def tpn_valid_values(self):\n return self.get_valid_values_map()","def get_undefs(self):\n return self._undefvars","def get_values(self, no_values=400):\r\n return [self.get_value() for i in range(no_values)]","def get_sub_values(self):\n return list()","def list_uses(self):\n return list(set(self._prop_typology['USE'].values))","def apply_check_annotation_list(row):\n if len(row) == 0:\n return(['blank'])\n else:\n return(row)","def valuerefs(self):\n return [ref(value) for value in self.itervalues()]","def get_recognized_values(self):\n return list(sorted(self._usr_to_hw.keys()))","def all(self):\r\n return self.attr_dict.keys()","def get_supplied_values(self):\n return self._supplied_values","def _list_usage_flags():\n yield from sorted(self._defs.items())\n if self._parent is None:\n if self._CONFIG_FLAG.name not in self._defs:\n yield (self._CONFIG_FLAG.name, self._CONFIG_FLAG)","def get_metric_list(self) -> List[str]:\n ...","def get_unlabelled_tweets_reannotation():\n conn = get_connection()\n c = conn.cursor()\n #res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression is null AND tweets.username IN (SELECT username FROM users WHERE mentions_depr=1)').fetchall()\n res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression IN (0, 1, 2) AND tweets.is_about_depression2 IS NULL ORDER BY random()').fetchall()\n conn.close()\n return np.array(res)","def type_hint_annotations(self) -> list[FakeAnnotation]:\n result: list[FakeAnnotation] = []\n for child in self.children:\n if child.type_annotation.get_local_types():\n result.append(child.type_annotation)\n return result","def values(self) -> list:\n return self.__values","def values(self):\r\n return [self[k] for k in self]","def bool_attr_list(gdbval, candidates):\n\n r = []\n for i in candidates:\n if long (gdbval[i]) != 0:\n r.append(i)\n pass\n pass\n return r","def valuerefs(self):\r\n return self.data.values()","def values(self):\n return self._tagged.values()","def get_annotations(self):\n entity = self.get_object()\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\n return Response(serializer.data)","def allowed_positions(self, curr_state):\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]","def allowed_positions(self, curr_state):\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]","def allowed_positions(self, curr_state):\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]","def _build_parsed_values(self):\n # need to exclude m times\n return self._parsed_values(EngineeringScienceRecoveredDataParticle.keys_exclude_times)","def science_parameter_list(cls):\n result = []\n for key in cls.list():\n if key not in GliderParticleKey.list():\n result.append(key)\n\n return result","def ListAnnotations(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def compact_list(self):\n return [ele for ele in self if ele is not None]","def GetValidLabelValues(self) -> \"std::vector< unsigned short,std::allocator< unsigned short > > const &\":\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3IUS3_GetValidLabelValues(self)","def get_filter_values(self):\n return [f.get() for f in self._filters[:-1]] # Ignore placeholder","def get_list_vars(my_vars):\n lists = []\n for var in my_vars:\n try:\n temp = my_vars[var].getValue()\n #print var + '=' + str(temp)\n except ValueError:\n lists.append(var)\n return lists","def getMissingIds(self):\n return self._missingIds"],"string":"[\n \"def get_unused_annotations(graph):\\n return graph.defined_annotation_keywords - get_annotations(graph)\",\n \"def get_annotation_values(graph, annotation):\\n return set(iter_annotation_values(graph, annotation))\",\n \"def metric_annotations_allow_list(self) -> Optional[pulumi.Input[str]]:\\n return pulumi.get(self, \\\"metric_annotations_allow_list\\\")\",\n \"def handle_enum(enum_annotations: Any) -> list:\\n result = []\\n for attribute in list(enum_annotations):\\n result.append(attribute.value)\\n return result\",\n \"def variables_used (self) :\\r\\n\\t\\treturn [i[0] for i in self.parameters]\",\n \"def unused_featurevalues():\\n\\n fvs = FeatureValue.objects.filter(feature__active=True)\\n unused_fvs = fvs.filter(languages__isnull=True)\\n natlang_only_fvs = fvs.filter(languages__language__natlang=True).exclude(languages__language__natlang=False)\\n\\n if not natlang_only_fvs:\\n # Natlangs had no unique features so return early\\n return unused_fvs\\n\\n # dsd\\n decorate = ((fv.id, fv) for fv in set(unused_fvs) | set(natlang_only_fvs))\\n sort = sorted(decorate)\\n return [fv for (_, fv) in sort]\",\n \"def get_misused_opt_arg_dec():\\n return list(incompletely_used_decorators.values())\",\n \"def list_value(self) -> global___Expression.RepeatedValue:\",\n \"def get_annotations(graph):\\n return set(_annotation_iter_helper(graph))\",\n \"def values(self):\\n return iter(util.annotate(v) for _, v in self._pairs())\",\n \"def unusedVars(self):\\n fullcode = self.code_cfg\\n variables = set([x[1:] for x in codeconfig_getvars(fullcode)])\\n exceptions = set(['complexity', 'code_cfg'])\\n clsvars = set(vars(self).keys())\\n nones = set(filter(lambda x: self.__dict__[x] is None, clsvars))\\n nones = nones.union(set(filter(lambda x: str(self.__dict__[x]) == \\\"\\\", clsvars)))\\n unused = clsvars - variables - exceptions - nones\\n return unused\",\n \"def get_values(self):\\n \\n return []\",\n \"def get_attribute_list(self):\\n attributes = [attr for attr in vars(self.entries[0]) if not attr.startswith('__')]\\n return attributes\",\n \"def _used_annotations(cls) -> set:\\n return set(field.type for field in dataclasses.fields(cls))\",\n \"def variables_used (self) :\\r\\n\\t\\treturn []\",\n \"def used_yvals(self):\\n return [y for y in self.yvals() if any([len(self.get_plaquette(x, y)) > 0\\n for x in self.xvals()])]\",\n \"def values(self) -> List:\\n pass\",\n \"def values(self):\\n return [_ for _ in self._dict.values()]\",\n \"def all_label_values(self, label_list_ids=None):\\n values = set()\\n\\n for label_list in self.label_lists.values():\\n if label_list_ids is None or label_list.idx in label_list_ids:\\n values = values.union(label_list.label_values())\\n\\n return values\",\n \"def _suppressions(self) -> List:\\n sonar, sonar_id = self._metric_source, self._sonar_id()\\n return [\\n (sonar.false_positives(sonar_id), sonar.false_positives_url(sonar_id),\\n \\\"Gemarkeerd als false positive in SonarQube\\\"),\\n (sonar.wont_fix(sonar_id), sonar.wont_fix_url(sonar_id),\\n \\\"Gemarkeerd als won't fix in SonarQube\\\"),\\n (sonar.suppressions(sonar_id), sonar.suppressions_url(sonar_id),\\n \\\"Gemarkeerd in de broncode met annotatie, commentaar (bijv. //NOSONAR) of pragma\\\")]\",\n \"def annotation_filter(self,annotations):\\n result = []\\n for key,value in annotations.items():\\n if key not in [Result.START_TIME,Result.END_TIME]:\\n result.append((key,value))\\n result.sort(key=operator.itemgetter(0))\\n return result\",\n \"def used_xvals(self):\\n return [x for x in self.xvals() if any([len(self.get_plaquette(x, y)) > 0\\n for y in self.yvals()])]\",\n \"def extensible_attributes_list_values():\\n return \\\"extensibleattributedef?\\\" \\\\\\n \\\"_return_fields=\\\" \\\\\\n \\\"list_values,\\\" \\\\\\n \\\"comment,\\\" \\\\\\n \\\"name,\\\" \\\\\\n \\\"type\\\"\",\n \"def get_all(cls, exclude_values: Iterator['CommonBusinessAdvertisingType'] = None) -> Tuple['CommonBusinessAdvertisingType']:\\n if exclude_values is None:\\n exclude_values = (cls.INVALID,)\\n # noinspection PyTypeChecker\\n value_list: Tuple[CommonBusinessAdvertisingType, ...] = tuple([value for value in cls.values if value not in exclude_values])\\n return value_list\",\n \"def get_values(self, names):\\n r = []\\n for n in names:\\n if n in self.raw_metrics:\\n r.append(self.raw_metrics[n])\\n else:\\n return None\\n return r\",\n \"def values(self):\\n return [entry.value for entry in self.table if entry.value is not None]\",\n \"def annotations(self):\\n return self._annotations\",\n \"def get_all(cls, exclude_values: Iterator['CommonBucksType'] = None) -> Tuple['CommonBucksType']:\\n if exclude_values is None:\\n exclude_values = (cls.INVALID,)\\n # noinspection PyTypeChecker\\n value_list: Tuple[CommonBucksType, ...] = tuple([value for value in cls.values if value not in exclude_values])\\n return value_list\",\n \"def get_list_of_present_entries(list_):\\n\\n _List = []\\n for x in list_:\\n if x not in _List:\\n if not None:\\n if not pd.isna(x):\\n _List.append(x)\\n return _List\",\n \"def missing_variables(self):\\n return [k for k in self.all_variables if k not in self._properties]\",\n \"def list_missing_for_deposit(self, needs: Tuple) -> List[int]:\\n missing = []\\n for item in needs:\\n if not any(self.needed_keywords_list(item)):\\n missing.append(item)\\n return missing\",\n \"def all_values(cls) -> List[str]:\\n return list(member.value for member in cls.__members__.values())\",\n \"def _get_values(self) -> ty.List[float]:\\r\\n ...\",\n \"def attributes(self):\\n attr = super(BaseDataRecord, self).attributes()\\n return [a for a in attr if a not in self.excluded()]\",\n \"def ignored_lists(self) -> List[str]:\\n return self.__lists_to_ignore\",\n \"def listglobal(self):\\n return list(self.attributes.keys())\",\n \"def items(self) -> List[Tuple[str, float]]:\\n return self._loss_dict.items()\",\n \"def get_all(cls, exclude_values: Iterator['CommonGameTagCategory'] = None) -> Tuple['CommonGameTagCategory']:\\n if exclude_values is None:\\n exclude_values = (cls.INVALID,)\\n # noinspection PyTypeChecker\\n value_list: Tuple[CommonGameTagCategory, ...] = tuple([value for value in cls.values if value not in exclude_values])\\n return value_list\",\n \"def excluded(cls):\\n return []\",\n \"def exclude_list(self):\\n pass\",\n \"def _more_properties_blacklist(self) -> List[str]:\\n return []\",\n \"def fully_hidden_arrays(self):\\n hidden = []\\n for m in self.masks():\\n invalid = self.get_property(m, '_no_valid_items')\\n if invalid: hidden.append(m)\\n return hidden\",\n \"def getVariables(self):\\n return [x for x in self.variables.values() if x is not None]\",\n \"def values(self, annotated=False, as_list=False, separator='\\\\t'):\\n if not self.attrs():\\n return None\\n if annotated:\\n list_repr = [\\\"{}:{}\\\".format(attr, val) for attr, val in\\n zip(self.__slots__, self._values(to_str=True))]\\n else:\\n list_repr = self._values(to_str=True)\\n if as_list:\\n return list_repr\\n else:\\n return separator.join(list_repr)\",\n \"def unused_evals(self):\\n\\t\\treturn self.Evals - self.nFES\",\n \"def values(self):\\n return [i.value for i in self.value]\",\n \"def get_existing_values(self): #DONE\\n return (value.value for value in self.address.values() if value.value)\",\n \"def excluded_from_scan(self):\\n return six.next(six.itervalues(self.zap._request(self.zap.base + 'spider/view/excludedFromScan/')))\",\n \"def getStatusValues(self):\\n return []\",\n \"def annotations(self):\\n\\n return self._annotations\",\n \"def get_all_variables(self):\\n return []\",\n \"def getVariableList(dataset):\\n variables = [v for v in dataset.variables.keys() if v not in dataset.dimensions.keys()]\\n for d in dataset.dimensions.keys():\\n try:\\n variables.pop(variables.index(dataset.variables[d].getncattr(\\\"bounds\\\")))\\n except:\\n pass\\n return variables\",\n \"def _get_vals(self, doc: Doc) -> Iterable[V]:\\n raise NotImplementedError\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def get_warning(self) -> List[str]:\\n return []\",\n \"def values():\",\n \"def values(self):\\n return self._list.values()\",\n \"def get_all_blacklisted_as_list(self):\\n try:\\n result = self.table.select().execute()\\n if result.rowcount >= 1:\\n return [x.values() for x in result]\\n elif result.rowcount == 0:\\n return []\\n except Exception as e:\\n self.log(e, self.identifier)\\n raise egg_errors.QueryNotPossible\",\n \"def _build_parsed_values(self):\\n # need to exclude sci times\\n return self._parsed_values(GpsPositionDataParticle.keys_exclude_all_times)\",\n \"def values(self):\\n return self.attrs.values()\",\n \"def get_all_variables(self):\\n return [self.item]\",\n \"def values(self):\\n return [p.value for p in self]\",\n \"def variables_used (self) :\\r\\n\\t\\t## These names do not contain dimension specification (everything in brackets\\r\\n\\t\\t## that comes after a name is am array index - either the arry was declared\\r\\n\\t\\t## correctly or it is wrong anyway, there is no implicit declaration of arrays) !\\r\\n\\r\\n\\t\\tresult = []\\r\\n\\r\\n\\t\\tfor l in self.equ_lists :\\r\\n\\t\\t\\tfor var_name in l :\\r\\n\\t\\t\\t\\tresult.append(var_name[0])\\r\\n\\t\\treturn result\",\n \"def get_marking_values():\\n array = np.arange(0, MAX_MARK_VALUE +1).tolist()\\n return array\",\n \"def get_vlans_list(self):\\n return self.vlans.keys()\",\n \"def __listAttr(self):\\n attr = dir(self) # already sorted\\n filter = []\\n for name in attr:\\n if name[:2] == '__': pass\\n elif name[:10] == '_HelpDoc__': pass # used to mask private attr\\n elif name in self.__exclude: pass\\n else: filter.append(name)\\n return filter\",\n \"def get_metric_variables(self) -> List[Any]:\\n with self._lock:\\n return self._get_metric_variables()\",\n \"def values(self):\\n return [getattr(self, a.name) for a in self.__attrs_attrs__]\",\n \"def getMetadataList(self):\\n return [ x.toTuple() for x in self.metadata ]\",\n \"def tpn_valid_values(self):\\n return self.get_valid_values_map()\",\n \"def get_undefs(self):\\n return self._undefvars\",\n \"def get_values(self, no_values=400):\\r\\n return [self.get_value() for i in range(no_values)]\",\n \"def get_sub_values(self):\\n return list()\",\n \"def list_uses(self):\\n return list(set(self._prop_typology['USE'].values))\",\n \"def apply_check_annotation_list(row):\\n if len(row) == 0:\\n return(['blank'])\\n else:\\n return(row)\",\n \"def valuerefs(self):\\n return [ref(value) for value in self.itervalues()]\",\n \"def get_recognized_values(self):\\n return list(sorted(self._usr_to_hw.keys()))\",\n \"def all(self):\\r\\n return self.attr_dict.keys()\",\n \"def get_supplied_values(self):\\n return self._supplied_values\",\n \"def _list_usage_flags():\\n yield from sorted(self._defs.items())\\n if self._parent is None:\\n if self._CONFIG_FLAG.name not in self._defs:\\n yield (self._CONFIG_FLAG.name, self._CONFIG_FLAG)\",\n \"def get_metric_list(self) -> List[str]:\\n ...\",\n \"def get_unlabelled_tweets_reannotation():\\n conn = get_connection()\\n c = conn.cursor()\\n #res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression is null AND tweets.username IN (SELECT username FROM users WHERE mentions_depr=1)').fetchall()\\n res = c.execute('SELECT * FROM tweets WHERE tweets.is_about_depression IN (0, 1, 2) AND tweets.is_about_depression2 IS NULL ORDER BY random()').fetchall()\\n conn.close()\\n return np.array(res)\",\n \"def type_hint_annotations(self) -> list[FakeAnnotation]:\\n result: list[FakeAnnotation] = []\\n for child in self.children:\\n if child.type_annotation.get_local_types():\\n result.append(child.type_annotation)\\n return result\",\n \"def values(self) -> list:\\n return self.__values\",\n \"def values(self):\\r\\n return [self[k] for k in self]\",\n \"def bool_attr_list(gdbval, candidates):\\n\\n r = []\\n for i in candidates:\\n if long (gdbval[i]) != 0:\\n r.append(i)\\n pass\\n pass\\n return r\",\n \"def valuerefs(self):\\r\\n return self.data.values()\",\n \"def values(self):\\n return self._tagged.values()\",\n \"def get_annotations(self):\\n entity = self.get_object()\\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\\n return Response(serializer.data)\",\n \"def allowed_positions(self, curr_state):\\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]\",\n \"def allowed_positions(self, curr_state):\\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]\",\n \"def allowed_positions(self, curr_state):\\n return [i for i, val in enumerate(curr_state) if np.isnan(val)]\",\n \"def _build_parsed_values(self):\\n # need to exclude m times\\n return self._parsed_values(EngineeringScienceRecoveredDataParticle.keys_exclude_times)\",\n \"def science_parameter_list(cls):\\n result = []\\n for key in cls.list():\\n if key not in GliderParticleKey.list():\\n result.append(key)\\n\\n return result\",\n \"def ListAnnotations(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def compact_list(self):\\n return [ele for ele in self if ele is not None]\",\n \"def GetValidLabelValues(self) -> \\\"std::vector< unsigned short,std::allocator< unsigned short > > const &\\\":\\n return _itkLabelStatisticsImageFilterPython.itkLabelStatisticsImageFilterIUS3IUS3_GetValidLabelValues(self)\",\n \"def get_filter_values(self):\\n return [f.get() for f in self._filters[:-1]] # Ignore placeholder\",\n \"def get_list_vars(my_vars):\\n lists = []\\n for var in my_vars:\\n try:\\n temp = my_vars[var].getValue()\\n #print var + '=' + str(temp)\\n except ValueError:\\n lists.append(var)\\n return lists\",\n \"def getMissingIds(self):\\n return self._missingIds\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68537354","0.62805945","0.59040225","0.589097","0.58017445","0.575836","0.5727465","0.57149005","0.56691","0.56430316","0.56349885","0.5633079","0.55975","0.55915046","0.55841595","0.5538164","0.5534096","0.5508441","0.5505978","0.55038834","0.54778254","0.5466189","0.54593086","0.5431938","0.541781","0.54102445","0.54101956","0.53927505","0.5387052","0.53804106","0.5376177","0.53563994","0.53514856","0.53388494","0.5327498","0.53253746","0.53250754","0.53141284","0.53117365","0.5303471","0.53014714","0.53001606","0.5292661","0.52795327","0.5276689","0.5241014","0.52335924","0.52295566","0.5227591","0.52253085","0.522123","0.51822335","0.5177975","0.5173918","0.5173918","0.5161531","0.5157869","0.5142549","0.5138164","0.51344436","0.5131604","0.51306236","0.5125615","0.51226276","0.512018","0.51174176","0.51174104","0.5112639","0.5108958","0.509681","0.5086913","0.50853026","0.5073947","0.50654316","0.5065414","0.5064668","0.50617415","0.50590545","0.50425905","0.50423044","0.5038368","0.50346863","0.5029108","0.5026647","0.50219274","0.5021883","0.5016225","0.5015588","0.50145406","0.5005632","0.5005632","0.5005632","0.50046396","0.5004212","0.49964938","0.49841878","0.49787003","0.49760407","0.49739504","0.49733436"],"string":"[\n \"0.68537354\",\n \"0.62805945\",\n \"0.59040225\",\n \"0.589097\",\n \"0.58017445\",\n \"0.575836\",\n \"0.5727465\",\n \"0.57149005\",\n \"0.56691\",\n \"0.56430316\",\n \"0.56349885\",\n \"0.5633079\",\n \"0.55975\",\n \"0.55915046\",\n \"0.55841595\",\n \"0.5538164\",\n \"0.5534096\",\n \"0.5508441\",\n \"0.5505978\",\n \"0.55038834\",\n \"0.54778254\",\n \"0.5466189\",\n \"0.54593086\",\n \"0.5431938\",\n \"0.541781\",\n \"0.54102445\",\n \"0.54101956\",\n \"0.53927505\",\n \"0.5387052\",\n \"0.53804106\",\n \"0.5376177\",\n \"0.53563994\",\n \"0.53514856\",\n \"0.53388494\",\n \"0.5327498\",\n \"0.53253746\",\n \"0.53250754\",\n \"0.53141284\",\n \"0.53117365\",\n \"0.5303471\",\n \"0.53014714\",\n \"0.53001606\",\n \"0.5292661\",\n \"0.52795327\",\n \"0.5276689\",\n \"0.5241014\",\n \"0.52335924\",\n \"0.52295566\",\n \"0.5227591\",\n \"0.52253085\",\n \"0.522123\",\n \"0.51822335\",\n \"0.5177975\",\n \"0.5173918\",\n \"0.5173918\",\n \"0.5161531\",\n \"0.5157869\",\n \"0.5142549\",\n \"0.5138164\",\n \"0.51344436\",\n \"0.5131604\",\n \"0.51306236\",\n \"0.5125615\",\n \"0.51226276\",\n \"0.512018\",\n \"0.51174176\",\n \"0.51174104\",\n \"0.5112639\",\n \"0.5108958\",\n \"0.509681\",\n \"0.5086913\",\n \"0.50853026\",\n \"0.5073947\",\n \"0.50654316\",\n \"0.5065414\",\n \"0.5064668\",\n \"0.50617415\",\n \"0.50590545\",\n \"0.50425905\",\n \"0.50423044\",\n \"0.5038368\",\n \"0.50346863\",\n \"0.5029108\",\n \"0.5026647\",\n \"0.50219274\",\n \"0.5021883\",\n \"0.5016225\",\n \"0.5015588\",\n \"0.50145406\",\n \"0.5005632\",\n \"0.5005632\",\n \"0.5005632\",\n \"0.50046396\",\n \"0.5004212\",\n \"0.49964938\",\n \"0.49841878\",\n \"0.49787003\",\n \"0.49760407\",\n \"0.49739504\",\n \"0.49733436\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7874108"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20163,"cells":{"query":{"kind":"string","value":"Gets annotation/value pairs for values for whom the search string is a substring"},"document":{"kind":"string","value":"def get_annotations_containing_keyword(graph, keyword):\n return [\n {\n 'annotation': annotation,\n 'value': value\n }\n for annotation, value in iter_annotation_value_pairs(graph)\n if keyword.lower() in value.lower()\n ]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _substring_occurrences(\n cls, in_str: str, substrings: Iterable[str]\n ) -> Dict[str, List[int]]:\n occurrences = {}\n for substring in substrings:\n occurrences[substring] = list(findall(substring, in_str))\n return occurrences","def search_in_tree(self, tree, substring):\n s_options_for_match = set()\n node = tree\n idx = 0\n substring_length = len(substring)\n while idx < substring_length and len(node[substring[idx]]) != 0:\n node = node[substring[idx]]\n s_options_for_match.update(node['end'])\n idx += 1\n if idx == substring_length:\n s_options_for_match.update(node['part'])\n\n return s_options_for_match","def searchRef(self, searchStr):\n filter = []\n attr = self.__listAttr()\n for name in attr:\n if searchStr.lower() in name.lower():\n doc = getattr(self, name)\n filter.append([name, doc]) \n # if in gloss, search for synonymes\n elif name in self.__glossIndex.keys():\n for altName in self.__glossIndex[name]['syn']:\n if searchStr in altName or altName in searchStr:\n doc = getattr(self, name)\n filter.append([name, doc])\n break\n \n return filter","def extract_strings_from_i(incarnato_fragments, genome, param):\r\n i_dict = {}\r\n i_fragment_regions = \"\"\r\n\r\n with open(incarnato_fragments) as f:\r\n for line in f:\r\n start, end = line.strip().split(\"_\")[1].split(\"-\")\r\n seq = next(f).strip()\r\n ss = next(f).strip()\r\n i_dict[(int(start), int(end))] = [seq,ss]\r\n\r\n for start, end in sorted(i_dict.keys()):\r\n temp = start - len(i_fragment_regions)\r\n gaps = \"\".join([\"_\" for x in range(0, temp)])\r\n i_fragment_regions += gaps\r\n i_fragment_regions += i_dict[(start, end)][param]\r\n \r\n tail = \"\".join([\"_\" for x in range(len(i_fragment_regions), genome+1)])\r\n i_fragment_regions += tail\r\n return i_fragment_regions","def search(self, searchstring):\n return {}","def occurrences(substring, string, sensitive=True):\n pos = -1\n o = []\n if not sensitive:\n substring = substring.lower()\n string = string.lower()\n while True:\n pos = string.find(substring, pos + 1)\n if pos == -1:\n return o\n else:\n o.append([pos, pos + len(substring)])","def find_all( source, substring, start=None, end=None, overlap=False ):\n return [x for x in find_all_iter( source, substring, start, end, overlap )]","def search(self):\n if self.substring in [None, \"\"]:\n print(\"Invalid Value For Substring\")\n elif self.string in [None, \"\"]:\n print(\"Invalid Value For String\")\n elif len(self.substring) > len(self.string):\n print(\"Length of Substring Less Than String\")\n else:\n posn = self.comparison()\n if posn == -1:\n print(\" Substring Not Found :: Search Failed\")\n else:\n print(\" Substring Found at Position --> \", posn+1)","def search(self, query_string):\n terms = query_string.lower().split()\n result = set(self.wordDict[terms[0]])\n if len(result) == 0:\n return list()\n else:\n for t in terms[2:]:\n records_containing_t = self.wordDict[t]\n result = result.intersection(records_containing_t)\n return [self.get_record_dict(id).getTuple() for id in result]","def get_search_tag_values(self, tag_name):\n return self._ruleset[tag_name].keys()","def find_possible(search_string):\n codes = []; names = []\n search_string = search_string.lower()\n for c,n in name_given_code.items():\n\n if (search_string in n):\n codes.append(c)\n names.append(n)\n\n return codes, names","def get_search_space(self) -> Dict[str, str]:","def by_label_contains(self, value):\n return {k: v for k, v in self.items() if value in k}","def search_student(student):\n result=[]\n for name,age in alumnos.items():\n if student.lower() in name.lower():\n result.append(name)\n\n print(f\"Result {result}\")\n return result","def search(self, value):\n pass","def get_searches(self,redcap,boolean,val):\n\t\tmatches = []\n\t\ttry:\n\t\t\tfor eachdict in self.get_data(redcap):\n\t\t\t\tif (boolean):\n\t\t\t\t\tif (re.search(str(val),eachdict[redcap].strip(),re.I)):\n\t\t\t\t\t\tmatches.append((eachdict['article_doi'],eachdict['record_id'],eachdict[redcap]))\n\t\t\t\telse:\n\t\t\t\t\tif not (re.search(str(val),eachdict[redcap].strip(),re.I)):\n\t\t\t\t\t\tmatches.append((eachdict['article_doi'],eachdict['record_id'],eachdict[redcap]))\n\t\texcept KeyError as e:\n\t\t\tprint(\"redcap field: '{}'\\nnot found. did you mean: '{}'?\\nverify and try again\".format(redcap,get_close_matches(redcap,[d['field_name'] for d in self.get_metadata()])))\n\n\t\treturn matches","def search(query_string):","def search_motif(sequences):\n motif = re.compile(r'(?=(N[^P](S|T)[^P]))') #N{P}[ST]{P}\n motif_index = {}\n\n for key,value in sequences.items():\n match_motif = re.finditer(motif, value)\n motif_start_list = []\n\n for i in match_motif:\n motif_start_list.append(str(i.start()+1))\n motif_index[key] = ' '.join(motif_start_list)\n return motif_index","def fn_find_in_map(self, value):\n\n current = self.root['Mappings']\n for index, key in enumerate(value):\n current = self.parser.exploded(current, key)\n return current","def get_series_by_substring(self, substr):\n self._build_series_cache()\n for series in self._series_cache.values():\n if substr.lower() in series.name.lower():\n return series","def substring_indexes(substring, string):\n last_found = -1 # Begin at -1 so the next position to search from is 0\n while True:\n # Find next index of substring, by starting after its last known position\n last_found = string.find(substring, last_found + 1)\n if last_found == -1: \n break # All occurrences have been found\n yield last_found","def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))","def search(self, sstrings, **kwargs):\n si = self.allinfo()\n return _search(si, sstrings, **kwargs)","def search_word(i_word, i_string, i_startpos=0):\n outputDict = {}\n idx = 0\n for pos in re.finditer(r'(\\b%s\\b)' % i_word, i_string[i_startpos:]):\n outputDict[idx] = [pos.start(), pos.end() + 1]\n idx += 1\n return outputDict","def _search(self, searchterm, pred, **args):\n # TODO: DRY with sparql_ontol_utils\n searchterm = searchterm.replace('%','.*')\n namedGraph = get_named_graph(self.handle)\n query = \"\"\"\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\n SELECT ?c WHERE {{\n GRAPH <{g}> {{\n ?c {pred} ?l\n FILTER regex(?l,'{s}','i')\n }}\n }}\n \"\"\".format(pred=pred, s=searchterm, g=namedGraph)\n bindings = run_sparql(query)\n return [r['c']['value'] for r in bindings]","def search_by_substring(db, table, column, substring):\n\n condition = column + \" LIKE \\'%\" + substring + \"%\\'\"\n result = select_columns(db, table, \"*\", condition=condition)\n\n return result","def searchByNameSubstring(self, substring):\n if substring.strip() == '':\n return None\n return self.filter(name__icontains=substring)","def indexof(self, value, tag=WORD):\n match = lambda a, b: a.endswith(\"*\") and b.startswith(a[:-1]) or a==b\n indices = []\n for i in range(len(self.words)):\n if match(value, unicode(self.get(i, tag))):\n indices.append(i)\n return indices","def lookup(self, term):\n results = []\n lookup_term = term.lower()\n for char, latex, description, user_description in self.entries:\n if (char == term or\n latex.startswith(lookup_term) or\n latex[1:].startswith(lookup_term) or\n lookup_term in description.lower() or\n (user_description and lookup_term in user_description)):\n results.append((char, latex, description, user_description))\n return results","def positions(self, searchstr: str):\n out = []\n for x in range(0, len(self.sa)):\n sub = self.sa[x]\n if searchstr == sub[0:len(searchstr)]:\n out.append(x)\n return out\n \n pass","def sequence_key_search(self,key,return_found_terms=False):\r\n if not return_found_terms:\r\n returnvalue = set()\r\n else:\r\n returnvalue = (set(),set())\r\n\r\n\r\n\r\n if key.startswith('GT_'):\r\n func_pred = '>='\r\n pred_len = 3\r\n elif key.startswith('LT_'):\r\n func_pred = '<='\r\n pred_len = 3\r\n elif key.startswith('=_'):\r\n func_pred = '='\r\n pred_len = 2\r\n elif key.startswith('G_'):\r\n func_pred = '>'\r\n pred_len = 2\r\n elif key.startswith('L_'):\r\n func_pred = '<'\r\n pred_len = 2\r\n elif key.startswith('E_'):\r\n func_pred = '='\r\n pred_len = 2\r\n elif key.startswith('R_'):\r\n func_pred = '/'\r\n pred_len = 2\r\n elif key.startswith('ALL_'):\r\n func_pred = '?'\r\n pred_len = 4\r\n\r\n else:\r\n return returnvalue\r\n\r\n key = key[pred_len:]\r\n if key.startswith(LEFTBRACKET):\r\n key = key[1:]\r\n left_more_than = True\r\n else:\r\n left_more_than = False\r\n if key.endswith(RIGHTBRACKET):\r\n key = key[:-1]\r\n right_less_than = True\r\n else:\r\n right_less_than = False\r\n\r\n if ATSIGN not in key:\r\n return returnvalue\r\n else:\r\n if SLASH in key:\r\n afterslash = key.split(SLASH)[1]\\\r\n .split(ATSIGN)[1]\\\r\n .replace(POUND,EMPTYCHAR)\\\r\n .replace(UNDERLINE,EMPTYCHAR)\r\n key = key.split(SLASH)[0]\r\n else:\r\n afterslash = EMPTYCHAR\r\n identifier = key.split(ATSIGN)[0]\r\n key_value = key.split(ATSIGN)[1]\r\n\r\n\r\n key_mark, key_value, key_type, key_value2 = self.parse_sequence_key(key_value,afterslash)\r\n\r\n\r\n if not self.default_dict['sequences'].query(term1=identifier,action='in'):\r\n return returnvalue\r\n sub_sequence = []\r\n\r\n\r\n\r\n if key_type == self.default_dict['sequences'].query(term1='#TYPE#',\r\n term2=identifier,\r\n action='get'):\r\n\r\n sequence = self.default_dict['sequences'].query(term1=identifier,\r\n action='get')\r\n if not key_value2:\r\n\r\n #If only one value entered\r\n\r\n sub_sequence = sequence.get(func_name=func_pred,item=key_value)\r\n\r\n else:\r\n\r\n # for a range of values\r\n\r\n if func_pred == '/':\r\n if left_more_than:\r\n left_func = '>'\r\n else:\r\n left_func = '>='\r\n if right_less_than:\r\n right_func = '<'\r\n else:\r\n right_func = '<='\r\n\r\n from_left_sequence = sequence.get(func_name=left_func,item=key_value)\r\n from_right_sequence = sequence.get(func_name=right_func,item=key_value2)\r\n sub_sequence = [x for x in from_left_sequence+from_right_sequence if x in from_left_sequence and x in from_right_sequence]\r\n\r\n\r\n returnset = set()\r\n returnfound = set()\r\n\r\n # Collate search terms\r\n for x_temp in sub_sequence:\r\n x_temp = identifier+ATSIGN+key_mark+str(x_temp)\r\n\r\n if x_temp.endswith('.0'):\r\n\r\n x_temp = x_temp[:-2]\r\n\r\n for y_temp in [x_temp+'.0',x_temp,DASH.join(x_temp.split(DASH)[0:2]),\r\n DASH.join(x_temp.split(DASH)[0:1])]:\r\n\r\n if y_temp in self.keys():\r\n returnset = returnset.union(self.get_indexes_for_key(y_temp))\r\n returnfound.add(y_temp)\r\n\r\n\r\n if not return_found_terms:\r\n return returnset\r\n else:\r\n return returnset, returnfound","def find_all(self, p):\n ln = self.ln\n t = self.t\n occurrences = []\n hints = self.__getHints(p)\n for i in hints:\n # compare rest char in pattern with chars in text after hinted substring\n if t[i + ln:i + len(p)] == p[ln:]:\n occurrences.append(i)\n return occurrences","def search(self, term) -> Iterable:\n # if the term is whitespace, return empty\n if not term.strip():\n yield from ()\n return\n # if the term is latin, let's search in meanings\n if re.match(r'^[a-zA-Z\\s]+$', term.strip()):\n for entry in self.entries:\n for sense in entry[\"senses\"]:\n if any(term in gloss for gloss in sense[\"glosses\"]):\n yield copy.deepcopy(entry)\n # the term is probably kana, let's search in writings and readings\n else:\n for entry in self.entries:\n if any(term in writing for writing in entry[\"writings\"] + entry[\"readings\"]):\n yield copy.deepcopy(entry)","def by_label_contains(self, value: str) -> RegistryType:\n return {k: v for k, v in self.items() if value in k}","def lookup(self, search_string):\n url = self.create_search_url(search_string)\n self.logger.debug(\"lookup: using search url: %s\" % url)\n search_results = self.get_search_results(url)\n results = []\n # Search results is an XML string with basic top level info about\n # all the entities that matched our search string..\n #\n dom = parseString(search_results).firstChild\n entity = first_child(dom, \"entity\")\n while entity:\n if self.parser.content == \"movies\":\n results.append(Movie(entity, self))\n else:\n results.append(Series(entity, self))\n entity = next_sibling(entity, \"entity\")\n return results","def getGlyphsMatching(propertyName, propertyValue):\n return utils.getGlyphsMatching(data, propertyName, propertyValue)","def subStringMatchExact(target, key):\n\tanswer_tuple = () # initialize the tuple we will return\n\tstart = 0 # use this initial the starting point for find()\n\twhile find(target, key, start) >=0:\n\t\tstart = find(target, key, start)\n\t\tanswer_tuple += (start,)\n\t\tstart+=1\n\treturn answer_tuple","def subStringMatchExact(target, key):\n\tanswer_tuple = () # initialize the tuple we will return\n\tstart = 0 # use this initial the starting point for find()\n\twhile find(target, key, start) >=0:\n\t\tstart = find(target, key, start)\n\t\tanswer_tuple += (start,)\n\t\tstart+=1\n\treturn answer_tuple","def search(cls, **kwargs):\n key = [key for key in kwargs][0]\n objects = cls.get_all()\n if isinstance(objects, dict):\n return objects\n results = []\n for i in objects:\n if is_substring(kwargs[key], getattr(i, key)):\n results.append(i)\n if not results:\n return {\n \"message\": \"No objects match the searched value.\",\n \"help\": \"Ensure arguments are of existent objects.\"\n }\n return results","def search(self, query_string):\n results = super(RelPathSearchableTextSource,\n self).search(query_string)\n relPaths = RELPATHVOC.keys()\n results = relPaths + list(results)\n return (r for r in results)","def getannotationstrings2(cann):\n cdesc = ''\n if cann['description']:\n cdesc += cann['description'] + ' ('\n if cann['annotationtype'] == 'diffexp':\n chigh = []\n clow = []\n call = []\n for cdet in cann['details']:\n if cdet[0] == 'all':\n call.append(cdet[1])\n continue\n if cdet[0] == 'low':\n clow.append(cdet[1])\n continue\n if cdet[0] == 'high':\n chigh.append(cdet[1])\n continue\n cdesc += ' high in '\n for cval in chigh:\n cdesc += cval + ' '\n cdesc += ' compared to '\n for cval in clow:\n cdesc += cval + ' '\n cdesc += ' in '\n for cval in call:\n cdesc += cval + ' '\n elif cann['annotationtype'] == 'isa':\n cdesc += ' is a '\n for cdet in cann['details']:\n cdesc += 'cdet,'\n elif cann['annotationtype'] == 'contamination':\n cdesc += 'contamination'\n else:\n cdesc += cann['annotationtype'] + ' '\n for cdet in cann['details']:\n cdesc = cdesc + ' ' + cdet[1] + ','\n\n if len(cdesc) >= 1 and cdesc[-1] == ',':\n cdesc = cdesc[:-1]\n return cdesc","def regex_match_string_names_for_values(self, string_name_preface, string_name_expression, string_substitutions):\r\n string_name, string_suffix = string_name_expression[:-1], string_name_expression[-1:]\r\n string_name_regex = \"^\\\\\" + string_name + \".\" + string_suffix + \"$\"\r\n string_value_matches = []\r\n for key in string_substitutions.keys():\r\n if re.fullmatch(string_name_regex, key):\r\n string_value_matches.append(string_name_preface+string_substitutions[key])\r\n\r\n return string_value_matches","def getLabelsByString(self, p_str): # real signature unknown; restored from __doc__\n pass","def substring_search(word, collection):\n return [item for item in sorted(collection) if item.startswith(word)]","def parse(cls, value: str) -> Tuple[str, Dict[str, str]]:\n raw_value = read_value_from_path(value)\n args: Dict[str, str] = {}\n\n if \"@\" in raw_value:\n args[\"region\"], raw_value = raw_value.split(\"@\", 1)\n\n # now find any other arguments that can be filters\n matches = re.findall(r\"([0-9a-zA-z_-]+:[^\\s$]+)\", raw_value)\n for match in matches:\n k, v = match.split(\":\", 1)\n args[k] = v\n\n return args.pop(\"name_regex\"), args","def match_start_string(list_to_search, substring):\n # Whitespace is stripped before and after the substring,\n # but not within (e.g. \" New York City \" -> \"New York City\").\n clean_substring = substring.lstrip().rstrip().lower()\n items_found = []\n ([items_found.append(item) for item in list_to_search\n if clean_substring == item[:len(clean_substring)].lower()])\n return items_found","def search(self, word):","def findall(pattern, string, overlapping=True, sensitive=True, regexp=False):\n if regexp:\n return SE.occurrences_re(pattern, string)\n if overlapping:\n return SE.occurrences(pattern, string, sensitive)\n else:\n return SE.full_words(pattern, string, sensitive)","def searchString(self, instring, maxMatches=_MAX_INT):\n return list(self.scanString(instring))","def GetAnnotations(args, messages):\n annotations = getattr(args, 'annotations', {})\n additional_property_messages = []\n if not annotations:\n return None\n\n for key, value in annotations.items():\n additional_property_messages.append(\n messages.V2Key.AnnotationsValue.AdditionalProperty(\n key=key, value=value))\n\n annotation_value_message = messages.V2Key.AnnotationsValue(\n additionalProperties=additional_property_messages)\n\n return annotation_value_message","def parameter_finder(target_list, search_list, msgflag=False, exact=False):\n target_list = [x.lower() for x in target_list]\n\n indexes = []\n\n if isinstance(search_list, str):\n cont = 0\n search_list = search_list.lower()\n for t in target_list:\n if exact == False and search_list in t:\n indexes.append(cont)\n elif exact == True and search_list == t:\n indexes.append(cont)\n cont += 1\n if isinstance(search_list, list):\n search_list = [x.lower() for x in search_list]\n\n for s in search_list:\n s = str(s)\n for cont, t in enumerate(target_list):\n if exact == False and s in t:\n print((s, t))\n indexes.append(cont)\n elif exact == True and s == t:\n print((s, t))\n indexes.append(cont)\n\n if msgflag == True:\n length = len(indexes)\n if length > 1: print(\"There were several ocurrences\")\n if length == 0: print(\"No ocurrences found\")\n\n return indexes","def search(self, term):","def getannotationstrings(cann):\n cdesc = ''\n if cann['description']:\n cdesc += cann['description'] + ' ('\n if cann['annotationtype'] == 'diffexp':\n chigh = []\n clow = []\n call = []\n for cdet in cann['details']:\n if cdet[0] == 'all':\n call.append(cdet[1])\n continue\n if cdet[0] == 'low':\n clow.append(cdet[1])\n continue\n if cdet[0] == 'high':\n chigh.append(cdet[1])\n continue\n cdesc += ' high in '\n for cval in chigh:\n cdesc += cval + ' '\n cdesc += ' compared to '\n for cval in clow:\n cdesc += cval + ' '\n cdesc += ' in '\n for cval in call:\n cdesc += cval + ' '\n elif cann['annotationtype'] == 'isa':\n cdesc += ' is a '\n for cdet in cann['details']:\n cdesc += 'cdet,'\n elif cann['annotationtype'] == 'contamination':\n cdesc += 'contamination'\n else:\n cdesc += cann['annotationtype'] + ' '\n for cdet in cann['details']:\n cdesc = cdesc + ' ' + cdet[1] + ','\n return cdesc","def search(self, text, location=\"\"):\n return [\n obj.name[len(location) + 1 : -3] for obj in self._file_model.search(text) if obj.name.startswith(location)\n ]","def subStringMatchOneSub(key,target):\n allAnswers = ()\n for miss in range(0,len(key)):\n # miss picks location for missing element\n # key1 and key2 are substrings to match\n key1 = key[:miss]\n key2 = key[miss+1:]\n #print 'breaking key',key,'into',key1,key2\n # match1 and match2 are tuples of locations of start of matches\n # for each substring in target\n match1 = subStringMatchExact(target,key1)\n match2 = subStringMatchExact(target,key2)\n # when we get here, we have two tuples of start points\n # need to filter pairs to decide which are correct\n filtered = constrainedMatchPair(match1,match2,len(key1))\n allAnswers = allAnswers + filtered\n #print 'match1',match1\n #print 'match2',match2\n #print 'possible matches for',key1,key2,'start at',filtered\n return allAnswers","def subStringMatchOneSub(key,target):\r\n allAnswers = ()\r\n for miss in range(0,len(key)):\r\n # miss picks location for missing element\r\n # key1 and key2 are substrings to match\r\n key1 = key[:miss]\r\n key2 = key[miss+1:]\r\n print 'breaking key',key,'into',key1,key2\r\n # match1 and match2 are tuples of locations of start of matches\r\n # for each substring in target\r\n match1 = subStringMatchExact(target,key1)\r\n match2 = subStringMatchExact(target,key2)\r\n # when we get here, we have two tuples of start points\r\n # need to filter pairs to decide which are correct\r\n filtered = constrainedMatchPair(match1,match2,len(key1))\r\n allAnswers = allAnswers + filtered\r\n print 'match1',match1\r\n print 'match2',match2\r\n print 'possible matches for',key1,key2,'start at',filtered\r\n return allAnswers","def find_key(dic, val): \n return [k for k, v in dic.iteritems() if re.search(v, val)]","def _od_substrings(offsets_dict):\n return sorted(offsets_dict[offsets_dict.keys()[0]].keys())","def substring_indexes(substring, string):\n last_found = -1 # Begin at -1 so the next position to search from is 0\n while True:\n # Find next index of substring, by starting after its last known position\n last_found = string.find(substring, last_found + 1)\n if last_found == -1:\n break # All occurrences have been found\n yield last_found","def find_strings(line, result):\n\n idx = 0\n while idx != -1:\n idx = extract_string(line, idx, result)","def doFindAllMatching(self, str):\n matches = []\n for value in self.doId2do.values():\n if re.search(str,repr(value)):\n matches.append(value)\n return matches","def subStringMatchOneSub(key,target):\n allAnswers = ()\n for miss in range(0,len(key)):\n # miss picks location for missing element\n # key1 and key2 are substrings to match\n key1 = key[:miss]\n key2 = key[miss+1:]\n print 'breaking key',key,'into',key1,key2\n # match1 and match2 are tuples of locations of start of matches\n # for each substring in target\n match1 = subStringMatchExact(target,key1)\n match2 = subStringMatchExact(target,key2)\n # when we get here, we have two tuples of start points\n # need to filter pairs to decide which are correct\n filtered = constrainedMatchPair(match1,match2,len(key1))\n allAnswers = allAnswers + filtered\n print 'match1',match1\n print 'match2',match2\n print 'possible matches for',key1,key2,'start at',filtered\n return allAnswers","def match_all_cui(s,max_len = 10, Eterm_cui = Eterm_cui):\n if len(s) == 0: \n return []\n sub_label = np.zeros(len(s),dtype = 'int')\n location_term = {}\n i = 0\n while i < len(s):\n for j in range(max_len+1,0,-1):\n temp = ' '.join(s[i:i+j])\n if temp in Eterm_cui:\n sub_label[i:i+j] = 1\n location_term[i] = [Eterm_cui[temp]]\n break#matched maximum string, so break\n i += j\n output = []\n for i in range(len(s)):\n if sub_label[i] == 0:#no match\n output += [s[i]]\n elif i in location_term:\n for cui in location_term[i][: :-1]:\n output += [cui]\n return output","def search(self, sstrings, **kwargs):\n if self._info is None or self._info is False:\n self._info = self.allinfo()\n return _search(self._info, sstrings, **kwargs)","def subStringMatchOneSub(key,target):\n allAnswers = ()\n for miss in range(0,len(key)):\n # miss picks location for missing element\n # key1 and key2 are substrings to match\n key1 = key[:miss]\n key2 = key[miss+1:]\n #print 'breaking key',key,'into',key1,key2\n # match1 and match2 are tuples of locations of start of matches\n # for each substring in target\n match1 = subStringMatchExact(target,key1)\n match2 = subStringMatchExact(target,key2)\n # when we get here, we have two tuples of start points\n # need to filter pairs to decide which are correct\n # and we need to remove the starting points of perfect matchs.\n perfect_matches = subStringMatchExact(target, key)\n filtered = constrainedMatchPair(match1,match2,len(key1), perfect_matches)\n\n allAnswers = allAnswers + filtered\n #print 'match1',match1\n #print 'match2',match2\n #print 'possible matches for',key1,key2,'start at',filtered\n return allAnswers","def get_patient(drs):\n for line in drs:\n if line.strip().startswith('sem'):\n datalist = line.split(':')\n for word in datalist: \n if word.count('patient') > 0:\n variable = word[6:7]\n for word in datalist:\n if word.startswith('pred({0}'.format(variable)):\n return word.split(',')[1]","def get_substring_offsets(string, substring):\n offsets = []\n ofs = -1\n while True:\n ofs = string.find(substring, ofs+1)\n if ofs < 0:\n break\n offsets.append(ofs)\n return set(offsets)","def search_by_contains(self, tl):\n print(\"Search by string\")\n string = input(\"Please enter search string: \")\n return tl.findall_contains(string)","def subStringMatchExact(target,key,length):\r\n index = find(target,key)\r\n if index < 0:\r\n return ()\r\n else:\r\n matches = subStringMatchExact(target[index+len(key):len(target)],key,length)\r\n index += (length - len(target))\r\n matches += (index,)\r\n print matches\r\n return matches","def mutt_search(self, term):\n attrs = (\"email_address\", \"name\", \"otherinfo\", \"extrainfo\")\n ret = list(\n filter(lambda aitem: any(\n term in getattr(aitem, attr, \"\") for attr in attrs\n ), self.addresses)\n )\n return ret","def getSpecific(self, keyword, key):","def sparse_it(self, query : str) -> Dict[str, int]:\n return matchingStrings(self.sentence,query)","def _filter_search_values(key: str, values: list, collection: list):\n return_data = []\n for item in collection:\n if any(val in values for val in item[key]):\n return_data.append(item)\n return return_data","def get_value(self) -> Dict[str, any]:","def subStringMatchExact(target,key):\r\n index = find(target,key)\r\n #print 'here',target,key,index\r\n if index < 0 or len(key) <= 0 or len(target) <= 0:\r\n return ()\r\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\r\n offset = index + len(key)\r\n temp_matches = ()\r\n #print matches\r\n if matches:\r\n for x in range(0, len(matches)) :\r\n temp_matches += ((matches[x] + offset),)\r\n #matches.insert(0,index)\r\n temp_matches = (index,) + temp_matches\r\n return temp_matches","def test_search_subnode_2_value(self):\n\n lista = []\n for (n, _) in self.parser.search(self.xml, 'subnodes@ref=2'):\n for (_, v2) in self.parser.search(n, 'subnode'):\n lista.append(v2)\n self.assertEqual(lista, ['S2.1', 'S2.2'])","def searchGlossary(self,keyword):\n\t\twords = []\n\n\t\tfor letter in glossary:\n\t\t\tfor word in glossary[letter]:\n\t\t\t\tprint word.keys()[0]\n\t\t\t\tif keyword.lower() in word.keys()[0].lower():\n\t\t\t\t\twords.append(word)\n\n\t\treturn words","def search_features_str(obs, VARIABLES):\n \n matched_features = []\n feature_count = sum([obs.data[i].value for i in range(len(obs.data))])\n \n if debugmode:\n obs_value_list = [obs.data[i].value for i in range(len(obs.data))]\n feature_index = [i for i, j in enumerate(obs_value_list) if j != 0] # matched features index (non zero counters)\n for index in feature_index:\n fName = obs.data[index].fName\n fVariable = obs.data[index].fVariable\n pos = VARIABLES[fVariable]['where']\n matched_features.append({fName:pos})\n \n return feature_count, matched_features","def doFindAll(self, str):\n matches = []\n for value in self.doId2do.values():\n if repr(value).find(str) >= 0:\n matches.append(value)\n return matches","def find_entries(citation_string):\n for idx, token in enumerate(citation_string):\n if token == \"@\":\n yield idx","def retrieve_meta(meta_text):\n\n with open(meta_text) as f:\n meta = f.readlines()\n matchers = ['RADIANCE_MULT_BAND_10', 'RADIANCE_ADD_BAND_10', 'K1_CONSTANT_BAND_10', 'K2_CONSTANT_BAND_10']\n matching = [process_string(s) for s in meta if any(xs in s for xs in matchers)]\n return matching","def substring_indexes(substring, string):\n last_found = -1 # Begin at -1 so the next position to search from is 0\n while True:\n # Find next index of substring, by starting after its last known position\n last_found = string.find(substring, last_found + 1)\n if last_found == -1:\n break # All occurrences have been found\n yield last_found + (len(substring) - 1) # Return for iterator and make index be at the end","def test_get_substrings_all(self):\n\n ans = [s.value() for s in self.sf.get_substrings(0, False)]\n\n expected_values = [(0, 1, 2, 3, 4, 5), (0, 1, 2, 3, 4), (1, 2, 3, 4, 5), (1, 2, 3, 4), \\\n (2, 3, 4, 5), (2, 3, 4), (3, 4, 5), (3, 4), (4, 5), (4,), (5,)]\n\n self.assertEqual(ans, expected_values)","def global_matches(self, text):\n\n matches = []\n n = len(text)\n\n for list in [ self.namespace ]:\n for word in list:\n if word[:n] == text:\n matches.append(word)\n\n return matches","def get_values(in_file, out_file, keyword1):\n return_data = 0\n str_data = ' '\n write_data = ''\n kw_position = -1\n next_row = 0\n occurences = 0\n start_position = 0\n count1 = 0\n count2 = 0\n i = 0\n try:\n with open(in_file, 'rt', encoding='utf-16-le') as fi:\n for line in fi: #For each line do the following\n str_data = line\n if next_row == 1: #Means that a valid keyword was found in the previous row\n i = 0\n count1 = 0\n count2 = 0\n while i < len(str_data): #Iterate until the amount of commas is reached, we know the amount of commas from the previous row\n i = i+1\n if str_data[i-1] == \",\": #Looks for the commas and count them with their positions in the string\n count1 = count1 + 1\n count2 = count2 + 1\n if count1 == occurences: #The keyword begin position is reached, get the position in the string\n start_position = i-1\n if count2 == (occurences + 1): #The keyword end position is reached, get the position in the string\n end_position = i-1\n i = len(str_data)\n start_position = start_position + 1 #Else the first comma is also copied for output\n if kw_position <= 2: #this part for when the keyword is at the beginning without a comma in front of it\n start_position = start_position - 1\n print('Value = ', str_data[start_position:end_position])\n write_data = str_data[start_position:end_position] + '\\n' #Build the data string with a new line appended to it\n with open(out_file, 'at') as fo: #Write the data string to a file\n fo.seek(0,2)\n fo.write(write_data)\n fo.close()\n next_row = 0\n kw_position = str_data.find(keyword1) #Check the keyword position in the line, -1 if not found\n if kw_position > -1: #If the keyword is found in the line\n next_row = 1 #set the next row to be processed for the keyword\n occurences = str_data.count(',', 0, kw_position) #Check how many comma's it is up to the keyword\n except IOError:\n print(\"Error in reading/writing file.\")\n return_data = 2\n else:\n print('Operation completed successfully.')\n return_data = 1\n finally:\n print(\"done\")\n return return_data","def construct_search(barcodes, args):\n\tsearch = []\n\tfor i, set in enumerate(barcodes):\n\t\tname = list(barcodes[i].keys())[0]\n\t\t\n\t\t# if type is variable, construct regex to match \n\t\tif barcodes[i][name]['type'] == 'variable':\n\t\t\t\n\t\t\t# add type, name, and bool specifiying if we want to translate\n\t\t\tsearch_dict = {'type':'variable'}\n\t\t\tsearch_dict['name'] = name\n\t\t\tsearch_dict['trans'] = barcodes[i][name]['translate']\n\t\t\t\n\t\t\t# if we allow mismatches\n\t\t\tif 'mismatches' in barcodes[i][name]:\n\t\t\t\tmismatches = barcodes[i][name]['mismatches']\n\t\t\telse:\n\t\t\t\tmismatches = 0\n\t\t\t\n\t\t\t# construct regex for searching\n\t\t\tsearch_dict['forward'] = construct_variable_regex(barcodes[i][name]['before'], barcodes[i][name]['after'], mismatches)\n\t\t\t\n\t\t\t#search_dict['forward'] = f\"{barcodes[i][name]['before']}(.+){barcodes[i][name]['after']}\"\n\t\t\tsearch.append(search_dict)\n\t\t\t\n\t\t# if type is constant, we need to check if we are allowing mismatches or not\n\t\telif barcodes[i][name]['type'] == 'constant':\n\t\t\t# if number of mismatches is specified\n\t\t\tsearch_dict = create_barcodes_search_dict(barcodes[i][name], args)\n\t\t\tsearch_dict['name'] = name\n\t\t\tsearch.append(search_dict)\n\t\t\t\t\t\t\n\treturn search","def text_search():\n existing_fields = self.attr_name_map[object_class]\n text = \"%{}%\".format(exp[\"text\"])\n p = lambda f: f.ilike(text)\n return or_(*(\n with_key(field, p)\n for field in fields\n if field in existing_fields\n ))","def generate_suggestions(search_string):\n\n root = read_data_model('data/data_model.pkl')\n with ListStream() as x:\n root.search(search_string, '')\n print [s.strip('\\n') for s in x.data if s != '\\n']","def kmp_search(full_str, sub_str):\n n, m = len(full_str), len(sub_str)\n result = []\n pi = get_partial_match(sub_str)\n begin, matched = 0, 0\n while begin <= (n - m):\n if matched < m and full_str[begin + matched] == sub_str[matched]:\n matched += 1\n if matched == m:\n result.append(begin)\n else:\n if matched == 0:\n begin += 1\n else:\n begin += (matched - pi[matched - 1])\n matched = pi[matched - 1]\n return result","def choose_variant_annotation(csq_string, variant_annotation_rank_dict, gene_ix, conseq_ix):\n minrank = len(variant_annotation_rank_dict)\n gene_id = 'NA'\n conseq = 'NA'\n\n for tr in csq_string.split(','):\n annots = tr.split('|')\n for v in annots[conseq_ix].split('&'):\n if v in variant_annotation_rank_dict:\n r = variant_annotation_rank_dict[v]\n if r<minrank:\n minrank = r\n gene_id = annots[gene_ix]\n conseq = v\n return gene_id, conseq","def find(self, str_tags=None, suffixed=False):\n if not str_tags:\n str_tags = VAR_SUFFIXES\n else:\n if not isinstance(str_tags, list): str_tags = [str_tags]\n found = []\n variables = self.variables()\n for v in variables:\n for str_tag in str_tags:\n if suffixed:\n if v.endswith(str_tag): found.append(v)\n else:\n if str_tag in v: found.append(v)\n return found","def find_string_in_control(self, control: cat.Control, seek_str: str) -> List[Tuple[str, str]]:\n hits: List[Tuple[str, str]] = []\n if control.parts:\n for part in control.parts:\n hits.extend(self._find_string_in_part(control.id, part, seek_str))\n return hits","def split_search(self, value: str, adapter: str = AGG_ADAPTER_NAME) -> Tuple[str, List[str]]:\n search = value.strip().lower()\n\n # Problem are fields containing \":\" from adapters that populate dynamic fields\n # PBUG: special check for 'custom attributes' coming from esx adapter.\n if \":\" in search and 'custom attributes' not in search:\n adapter_split, field = [x.strip() for x in search.split(\":\", 1)]\n if not adapter_split:\n adapter_split = adapter\n else:\n field = search\n adapter_split = adapter\n qual_check = re.match(r\"adapters_data\\.(.*?)\\.\", field)\n if qual_check and len(qual_check.groups()) == 1:\n adapter_split = qual_check.groups()[0]\n\n adapter_split = strip_right(obj=adapter_split.lower().strip(), fix=\"_adapter\")\n\n fields = split_str(\n obj=field,\n split=\",\",\n strip=None,\n do_strip=True,\n lower=True,\n empty=False,\n )\n\n if not fields:\n raise ApiError(f\"No fields provided in {value!r}, format must be 'adapter:field'\")\n return adapter_split, fields","def contains(self, searchstr: str):\n for x in self.sa:\n if searchstr in x:\n return True\n pass","def extract_strings(f):\n strings = re.findall(strregex,f)\n return strings","def get_strings(\n self,\n size: Union[int, Tuple[int, int]],\n feature: Union[str, Iterable[str]] = None,\n ) -> List[str]:\n query = self._prepare_query(size, feature)\n return [\n document['_source']['term']\n for document in self._db.get(query)['hits']['hits']\n ]","def search(self, searchString):\n resultsDict = {}\n\n\n\n #-------------------- \n # Projects, subjects, experiments\n #-------------------- \n levelTags = {}\n levelTags['projects'] = ['ID', \n 'secondary_ID',\n 'name', 'pi_firstname', \n 'pi_lastname', \n 'description']\n levelTags['subjects'] = ['ID', 'label']\n levelTags['experiments'] = ['ID', 'label']\n\n\n\n #-------------------- \n # Looping through all of the levels,\n # constructing a searchQuery for each based\n # on the relevant columns.\n #-------------------- \n levels = ['projects', 'subjects', 'experiments']\n for level in levels:\n resultsDict[level] = []\n for levelTag in levelTags[level]:\n searchStr = '/%s?%s=*%s*'%(level, levelTag, searchString)\n #\n # Experiments: only search folders with images\n #\n if level == 'experiments':\n searchStr2 = searchStr + '&xsiType=xnat:mrSessionData'\n searchStr = searchStr + '&xsiType=xnat:petSessionData'\n resultsDict[level] = resultsDict[level] + \\\n self.__getJson(searchStr2)\n resultsDict[level] = resultsDict[level] + \\\n self.__getJson(searchStr)\n\n\n\n return resultsDict","def find_matches(self, sentence):\n # Split the sentence in words (tokens)\n tokens = tokenize(sentence)\n # Define a list to hold the matches\n matches = []\n # Go over all the words in the sentence\n for i in xrange(len(tokens)):\n current_store = self.store_dict\n # Go over all the words starting from the current word\n for j in xrange(i, len(tokens)):\n word = tokens[j]\n if word in current_store:\n # If the word is in the current dictionary, update this current dictionary,\n # and check if there is an _end symbol\n current_store = current_store[word]\n if self._end in current_store:\n # If there is an _end symbol, add the current match to the list of matches.\n matches.append(current_store[self._end])\n else:\n # Break and start again with the next word if the word is not \n # in the current dictionary\n break\n return matches","def get_proposal_terms(search, tokens):\n\tif isinstance(tokens, str):\n\t\ttokens = [tokens]\n\tfound = search.get(tokens[0], {})\n\tif found:\n\t\tif tokens[1:]:\n\t\t\tfound = get_proposal_terms(found, tokens[1:])\n\t\telse:\n\t\t\tfound = []\n\telse:\n\t\ttoken_0 = tokens[0]\n\t\tfound = [term for term in search.keys() if term.startswith(token_0) and term != token_0]\n\treturn found","def consensus_scan(self, fa):\n regexp = \"\".join([\"[\" + \"\".join(self.iupac[x.upper()]) + \"]\" for x in self.to_consensusv2()])\n p = re.compile(regexp)\n matches = {}\n for name,seq in fa.items():\n matches[name] = [] \n for match in p.finditer(seq):\n middle = (match.span()[1] + match.span()[0]) / 2\n matches[name].append(middle)\n return matches"],"string":"[\n \"def _substring_occurrences(\\n cls, in_str: str, substrings: Iterable[str]\\n ) -> Dict[str, List[int]]:\\n occurrences = {}\\n for substring in substrings:\\n occurrences[substring] = list(findall(substring, in_str))\\n return occurrences\",\n \"def search_in_tree(self, tree, substring):\\n s_options_for_match = set()\\n node = tree\\n idx = 0\\n substring_length = len(substring)\\n while idx < substring_length and len(node[substring[idx]]) != 0:\\n node = node[substring[idx]]\\n s_options_for_match.update(node['end'])\\n idx += 1\\n if idx == substring_length:\\n s_options_for_match.update(node['part'])\\n\\n return s_options_for_match\",\n \"def searchRef(self, searchStr):\\n filter = []\\n attr = self.__listAttr()\\n for name in attr:\\n if searchStr.lower() in name.lower():\\n doc = getattr(self, name)\\n filter.append([name, doc]) \\n # if in gloss, search for synonymes\\n elif name in self.__glossIndex.keys():\\n for altName in self.__glossIndex[name]['syn']:\\n if searchStr in altName or altName in searchStr:\\n doc = getattr(self, name)\\n filter.append([name, doc])\\n break\\n \\n return filter\",\n \"def extract_strings_from_i(incarnato_fragments, genome, param):\\r\\n i_dict = {}\\r\\n i_fragment_regions = \\\"\\\"\\r\\n\\r\\n with open(incarnato_fragments) as f:\\r\\n for line in f:\\r\\n start, end = line.strip().split(\\\"_\\\")[1].split(\\\"-\\\")\\r\\n seq = next(f).strip()\\r\\n ss = next(f).strip()\\r\\n i_dict[(int(start), int(end))] = [seq,ss]\\r\\n\\r\\n for start, end in sorted(i_dict.keys()):\\r\\n temp = start - len(i_fragment_regions)\\r\\n gaps = \\\"\\\".join([\\\"_\\\" for x in range(0, temp)])\\r\\n i_fragment_regions += gaps\\r\\n i_fragment_regions += i_dict[(start, end)][param]\\r\\n \\r\\n tail = \\\"\\\".join([\\\"_\\\" for x in range(len(i_fragment_regions), genome+1)])\\r\\n i_fragment_regions += tail\\r\\n return i_fragment_regions\",\n \"def search(self, searchstring):\\n return {}\",\n \"def occurrences(substring, string, sensitive=True):\\n pos = -1\\n o = []\\n if not sensitive:\\n substring = substring.lower()\\n string = string.lower()\\n while True:\\n pos = string.find(substring, pos + 1)\\n if pos == -1:\\n return o\\n else:\\n o.append([pos, pos + len(substring)])\",\n \"def find_all( source, substring, start=None, end=None, overlap=False ):\\n return [x for x in find_all_iter( source, substring, start, end, overlap )]\",\n \"def search(self):\\n if self.substring in [None, \\\"\\\"]:\\n print(\\\"Invalid Value For Substring\\\")\\n elif self.string in [None, \\\"\\\"]:\\n print(\\\"Invalid Value For String\\\")\\n elif len(self.substring) > len(self.string):\\n print(\\\"Length of Substring Less Than String\\\")\\n else:\\n posn = self.comparison()\\n if posn == -1:\\n print(\\\" Substring Not Found :: Search Failed\\\")\\n else:\\n print(\\\" Substring Found at Position --> \\\", posn+1)\",\n \"def search(self, query_string):\\n terms = query_string.lower().split()\\n result = set(self.wordDict[terms[0]])\\n if len(result) == 0:\\n return list()\\n else:\\n for t in terms[2:]:\\n records_containing_t = self.wordDict[t]\\n result = result.intersection(records_containing_t)\\n return [self.get_record_dict(id).getTuple() for id in result]\",\n \"def get_search_tag_values(self, tag_name):\\n return self._ruleset[tag_name].keys()\",\n \"def find_possible(search_string):\\n codes = []; names = []\\n search_string = search_string.lower()\\n for c,n in name_given_code.items():\\n\\n if (search_string in n):\\n codes.append(c)\\n names.append(n)\\n\\n return codes, names\",\n \"def get_search_space(self) -> Dict[str, str]:\",\n \"def by_label_contains(self, value):\\n return {k: v for k, v in self.items() if value in k}\",\n \"def search_student(student):\\n result=[]\\n for name,age in alumnos.items():\\n if student.lower() in name.lower():\\n result.append(name)\\n\\n print(f\\\"Result {result}\\\")\\n return result\",\n \"def search(self, value):\\n pass\",\n \"def get_searches(self,redcap,boolean,val):\\n\\t\\tmatches = []\\n\\t\\ttry:\\n\\t\\t\\tfor eachdict in self.get_data(redcap):\\n\\t\\t\\t\\tif (boolean):\\n\\t\\t\\t\\t\\tif (re.search(str(val),eachdict[redcap].strip(),re.I)):\\n\\t\\t\\t\\t\\t\\tmatches.append((eachdict['article_doi'],eachdict['record_id'],eachdict[redcap]))\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tif not (re.search(str(val),eachdict[redcap].strip(),re.I)):\\n\\t\\t\\t\\t\\t\\tmatches.append((eachdict['article_doi'],eachdict['record_id'],eachdict[redcap]))\\n\\t\\texcept KeyError as e:\\n\\t\\t\\tprint(\\\"redcap field: '{}'\\\\nnot found. did you mean: '{}'?\\\\nverify and try again\\\".format(redcap,get_close_matches(redcap,[d['field_name'] for d in self.get_metadata()])))\\n\\n\\t\\treturn matches\",\n \"def search(query_string):\",\n \"def search_motif(sequences):\\n motif = re.compile(r'(?=(N[^P](S|T)[^P]))') #N{P}[ST]{P}\\n motif_index = {}\\n\\n for key,value in sequences.items():\\n match_motif = re.finditer(motif, value)\\n motif_start_list = []\\n\\n for i in match_motif:\\n motif_start_list.append(str(i.start()+1))\\n motif_index[key] = ' '.join(motif_start_list)\\n return motif_index\",\n \"def fn_find_in_map(self, value):\\n\\n current = self.root['Mappings']\\n for index, key in enumerate(value):\\n current = self.parser.exploded(current, key)\\n return current\",\n \"def get_series_by_substring(self, substr):\\n self._build_series_cache()\\n for series in self._series_cache.values():\\n if substr.lower() in series.name.lower():\\n return series\",\n \"def substring_indexes(substring, string):\\n last_found = -1 # Begin at -1 so the next position to search from is 0\\n while True:\\n # Find next index of substring, by starting after its last known position\\n last_found = string.find(substring, last_found + 1)\\n if last_found == -1: \\n break # All occurrences have been found\\n yield last_found\",\n \"def get_annotation_values(graph, annotation):\\n return set(iter_annotation_values(graph, annotation))\",\n \"def search(self, sstrings, **kwargs):\\n si = self.allinfo()\\n return _search(si, sstrings, **kwargs)\",\n \"def search_word(i_word, i_string, i_startpos=0):\\n outputDict = {}\\n idx = 0\\n for pos in re.finditer(r'(\\\\b%s\\\\b)' % i_word, i_string[i_startpos:]):\\n outputDict[idx] = [pos.start(), pos.end() + 1]\\n idx += 1\\n return outputDict\",\n \"def _search(self, searchterm, pred, **args):\\n # TODO: DRY with sparql_ontol_utils\\n searchterm = searchterm.replace('%','.*')\\n namedGraph = get_named_graph(self.handle)\\n query = \\\"\\\"\\\"\\n prefix oboInOwl: <http://www.geneontology.org/formats/oboInOwl#>\\n SELECT ?c WHERE {{\\n GRAPH <{g}> {{\\n ?c {pred} ?l\\n FILTER regex(?l,'{s}','i')\\n }}\\n }}\\n \\\"\\\"\\\".format(pred=pred, s=searchterm, g=namedGraph)\\n bindings = run_sparql(query)\\n return [r['c']['value'] for r in bindings]\",\n \"def search_by_substring(db, table, column, substring):\\n\\n condition = column + \\\" LIKE \\\\'%\\\" + substring + \\\"%\\\\'\\\"\\n result = select_columns(db, table, \\\"*\\\", condition=condition)\\n\\n return result\",\n \"def searchByNameSubstring(self, substring):\\n if substring.strip() == '':\\n return None\\n return self.filter(name__icontains=substring)\",\n \"def indexof(self, value, tag=WORD):\\n match = lambda a, b: a.endswith(\\\"*\\\") and b.startswith(a[:-1]) or a==b\\n indices = []\\n for i in range(len(self.words)):\\n if match(value, unicode(self.get(i, tag))):\\n indices.append(i)\\n return indices\",\n \"def lookup(self, term):\\n results = []\\n lookup_term = term.lower()\\n for char, latex, description, user_description in self.entries:\\n if (char == term or\\n latex.startswith(lookup_term) or\\n latex[1:].startswith(lookup_term) or\\n lookup_term in description.lower() or\\n (user_description and lookup_term in user_description)):\\n results.append((char, latex, description, user_description))\\n return results\",\n \"def positions(self, searchstr: str):\\n out = []\\n for x in range(0, len(self.sa)):\\n sub = self.sa[x]\\n if searchstr == sub[0:len(searchstr)]:\\n out.append(x)\\n return out\\n \\n pass\",\n \"def sequence_key_search(self,key,return_found_terms=False):\\r\\n if not return_found_terms:\\r\\n returnvalue = set()\\r\\n else:\\r\\n returnvalue = (set(),set())\\r\\n\\r\\n\\r\\n\\r\\n if key.startswith('GT_'):\\r\\n func_pred = '>='\\r\\n pred_len = 3\\r\\n elif key.startswith('LT_'):\\r\\n func_pred = '<='\\r\\n pred_len = 3\\r\\n elif key.startswith('=_'):\\r\\n func_pred = '='\\r\\n pred_len = 2\\r\\n elif key.startswith('G_'):\\r\\n func_pred = '>'\\r\\n pred_len = 2\\r\\n elif key.startswith('L_'):\\r\\n func_pred = '<'\\r\\n pred_len = 2\\r\\n elif key.startswith('E_'):\\r\\n func_pred = '='\\r\\n pred_len = 2\\r\\n elif key.startswith('R_'):\\r\\n func_pred = '/'\\r\\n pred_len = 2\\r\\n elif key.startswith('ALL_'):\\r\\n func_pred = '?'\\r\\n pred_len = 4\\r\\n\\r\\n else:\\r\\n return returnvalue\\r\\n\\r\\n key = key[pred_len:]\\r\\n if key.startswith(LEFTBRACKET):\\r\\n key = key[1:]\\r\\n left_more_than = True\\r\\n else:\\r\\n left_more_than = False\\r\\n if key.endswith(RIGHTBRACKET):\\r\\n key = key[:-1]\\r\\n right_less_than = True\\r\\n else:\\r\\n right_less_than = False\\r\\n\\r\\n if ATSIGN not in key:\\r\\n return returnvalue\\r\\n else:\\r\\n if SLASH in key:\\r\\n afterslash = key.split(SLASH)[1]\\\\\\r\\n .split(ATSIGN)[1]\\\\\\r\\n .replace(POUND,EMPTYCHAR)\\\\\\r\\n .replace(UNDERLINE,EMPTYCHAR)\\r\\n key = key.split(SLASH)[0]\\r\\n else:\\r\\n afterslash = EMPTYCHAR\\r\\n identifier = key.split(ATSIGN)[0]\\r\\n key_value = key.split(ATSIGN)[1]\\r\\n\\r\\n\\r\\n key_mark, key_value, key_type, key_value2 = self.parse_sequence_key(key_value,afterslash)\\r\\n\\r\\n\\r\\n if not self.default_dict['sequences'].query(term1=identifier,action='in'):\\r\\n return returnvalue\\r\\n sub_sequence = []\\r\\n\\r\\n\\r\\n\\r\\n if key_type == self.default_dict['sequences'].query(term1='#TYPE#',\\r\\n term2=identifier,\\r\\n action='get'):\\r\\n\\r\\n sequence = self.default_dict['sequences'].query(term1=identifier,\\r\\n action='get')\\r\\n if not key_value2:\\r\\n\\r\\n #If only one value entered\\r\\n\\r\\n sub_sequence = sequence.get(func_name=func_pred,item=key_value)\\r\\n\\r\\n else:\\r\\n\\r\\n # for a range of values\\r\\n\\r\\n if func_pred == '/':\\r\\n if left_more_than:\\r\\n left_func = '>'\\r\\n else:\\r\\n left_func = '>='\\r\\n if right_less_than:\\r\\n right_func = '<'\\r\\n else:\\r\\n right_func = '<='\\r\\n\\r\\n from_left_sequence = sequence.get(func_name=left_func,item=key_value)\\r\\n from_right_sequence = sequence.get(func_name=right_func,item=key_value2)\\r\\n sub_sequence = [x for x in from_left_sequence+from_right_sequence if x in from_left_sequence and x in from_right_sequence]\\r\\n\\r\\n\\r\\n returnset = set()\\r\\n returnfound = set()\\r\\n\\r\\n # Collate search terms\\r\\n for x_temp in sub_sequence:\\r\\n x_temp = identifier+ATSIGN+key_mark+str(x_temp)\\r\\n\\r\\n if x_temp.endswith('.0'):\\r\\n\\r\\n x_temp = x_temp[:-2]\\r\\n\\r\\n for y_temp in [x_temp+'.0',x_temp,DASH.join(x_temp.split(DASH)[0:2]),\\r\\n DASH.join(x_temp.split(DASH)[0:1])]:\\r\\n\\r\\n if y_temp in self.keys():\\r\\n returnset = returnset.union(self.get_indexes_for_key(y_temp))\\r\\n returnfound.add(y_temp)\\r\\n\\r\\n\\r\\n if not return_found_terms:\\r\\n return returnset\\r\\n else:\\r\\n return returnset, returnfound\",\n \"def find_all(self, p):\\n ln = self.ln\\n t = self.t\\n occurrences = []\\n hints = self.__getHints(p)\\n for i in hints:\\n # compare rest char in pattern with chars in text after hinted substring\\n if t[i + ln:i + len(p)] == p[ln:]:\\n occurrences.append(i)\\n return occurrences\",\n \"def search(self, term) -> Iterable:\\n # if the term is whitespace, return empty\\n if not term.strip():\\n yield from ()\\n return\\n # if the term is latin, let's search in meanings\\n if re.match(r'^[a-zA-Z\\\\s]+$', term.strip()):\\n for entry in self.entries:\\n for sense in entry[\\\"senses\\\"]:\\n if any(term in gloss for gloss in sense[\\\"glosses\\\"]):\\n yield copy.deepcopy(entry)\\n # the term is probably kana, let's search in writings and readings\\n else:\\n for entry in self.entries:\\n if any(term in writing for writing in entry[\\\"writings\\\"] + entry[\\\"readings\\\"]):\\n yield copy.deepcopy(entry)\",\n \"def by_label_contains(self, value: str) -> RegistryType:\\n return {k: v for k, v in self.items() if value in k}\",\n \"def lookup(self, search_string):\\n url = self.create_search_url(search_string)\\n self.logger.debug(\\\"lookup: using search url: %s\\\" % url)\\n search_results = self.get_search_results(url)\\n results = []\\n # Search results is an XML string with basic top level info about\\n # all the entities that matched our search string..\\n #\\n dom = parseString(search_results).firstChild\\n entity = first_child(dom, \\\"entity\\\")\\n while entity:\\n if self.parser.content == \\\"movies\\\":\\n results.append(Movie(entity, self))\\n else:\\n results.append(Series(entity, self))\\n entity = next_sibling(entity, \\\"entity\\\")\\n return results\",\n \"def getGlyphsMatching(propertyName, propertyValue):\\n return utils.getGlyphsMatching(data, propertyName, propertyValue)\",\n \"def subStringMatchExact(target, key):\\n\\tanswer_tuple = () # initialize the tuple we will return\\n\\tstart = 0 # use this initial the starting point for find()\\n\\twhile find(target, key, start) >=0:\\n\\t\\tstart = find(target, key, start)\\n\\t\\tanswer_tuple += (start,)\\n\\t\\tstart+=1\\n\\treturn answer_tuple\",\n \"def subStringMatchExact(target, key):\\n\\tanswer_tuple = () # initialize the tuple we will return\\n\\tstart = 0 # use this initial the starting point for find()\\n\\twhile find(target, key, start) >=0:\\n\\t\\tstart = find(target, key, start)\\n\\t\\tanswer_tuple += (start,)\\n\\t\\tstart+=1\\n\\treturn answer_tuple\",\n \"def search(cls, **kwargs):\\n key = [key for key in kwargs][0]\\n objects = cls.get_all()\\n if isinstance(objects, dict):\\n return objects\\n results = []\\n for i in objects:\\n if is_substring(kwargs[key], getattr(i, key)):\\n results.append(i)\\n if not results:\\n return {\\n \\\"message\\\": \\\"No objects match the searched value.\\\",\\n \\\"help\\\": \\\"Ensure arguments are of existent objects.\\\"\\n }\\n return results\",\n \"def search(self, query_string):\\n results = super(RelPathSearchableTextSource,\\n self).search(query_string)\\n relPaths = RELPATHVOC.keys()\\n results = relPaths + list(results)\\n return (r for r in results)\",\n \"def getannotationstrings2(cann):\\n cdesc = ''\\n if cann['description']:\\n cdesc += cann['description'] + ' ('\\n if cann['annotationtype'] == 'diffexp':\\n chigh = []\\n clow = []\\n call = []\\n for cdet in cann['details']:\\n if cdet[0] == 'all':\\n call.append(cdet[1])\\n continue\\n if cdet[0] == 'low':\\n clow.append(cdet[1])\\n continue\\n if cdet[0] == 'high':\\n chigh.append(cdet[1])\\n continue\\n cdesc += ' high in '\\n for cval in chigh:\\n cdesc += cval + ' '\\n cdesc += ' compared to '\\n for cval in clow:\\n cdesc += cval + ' '\\n cdesc += ' in '\\n for cval in call:\\n cdesc += cval + ' '\\n elif cann['annotationtype'] == 'isa':\\n cdesc += ' is a '\\n for cdet in cann['details']:\\n cdesc += 'cdet,'\\n elif cann['annotationtype'] == 'contamination':\\n cdesc += 'contamination'\\n else:\\n cdesc += cann['annotationtype'] + ' '\\n for cdet in cann['details']:\\n cdesc = cdesc + ' ' + cdet[1] + ','\\n\\n if len(cdesc) >= 1 and cdesc[-1] == ',':\\n cdesc = cdesc[:-1]\\n return cdesc\",\n \"def regex_match_string_names_for_values(self, string_name_preface, string_name_expression, string_substitutions):\\r\\n string_name, string_suffix = string_name_expression[:-1], string_name_expression[-1:]\\r\\n string_name_regex = \\\"^\\\\\\\\\\\" + string_name + \\\".\\\" + string_suffix + \\\"$\\\"\\r\\n string_value_matches = []\\r\\n for key in string_substitutions.keys():\\r\\n if re.fullmatch(string_name_regex, key):\\r\\n string_value_matches.append(string_name_preface+string_substitutions[key])\\r\\n\\r\\n return string_value_matches\",\n \"def getLabelsByString(self, p_str): # real signature unknown; restored from __doc__\\n pass\",\n \"def substring_search(word, collection):\\n return [item for item in sorted(collection) if item.startswith(word)]\",\n \"def parse(cls, value: str) -> Tuple[str, Dict[str, str]]:\\n raw_value = read_value_from_path(value)\\n args: Dict[str, str] = {}\\n\\n if \\\"@\\\" in raw_value:\\n args[\\\"region\\\"], raw_value = raw_value.split(\\\"@\\\", 1)\\n\\n # now find any other arguments that can be filters\\n matches = re.findall(r\\\"([0-9a-zA-z_-]+:[^\\\\s$]+)\\\", raw_value)\\n for match in matches:\\n k, v = match.split(\\\":\\\", 1)\\n args[k] = v\\n\\n return args.pop(\\\"name_regex\\\"), args\",\n \"def match_start_string(list_to_search, substring):\\n # Whitespace is stripped before and after the substring,\\n # but not within (e.g. \\\" New York City \\\" -> \\\"New York City\\\").\\n clean_substring = substring.lstrip().rstrip().lower()\\n items_found = []\\n ([items_found.append(item) for item in list_to_search\\n if clean_substring == item[:len(clean_substring)].lower()])\\n return items_found\",\n \"def search(self, word):\",\n \"def findall(pattern, string, overlapping=True, sensitive=True, regexp=False):\\n if regexp:\\n return SE.occurrences_re(pattern, string)\\n if overlapping:\\n return SE.occurrences(pattern, string, sensitive)\\n else:\\n return SE.full_words(pattern, string, sensitive)\",\n \"def searchString(self, instring, maxMatches=_MAX_INT):\\n return list(self.scanString(instring))\",\n \"def GetAnnotations(args, messages):\\n annotations = getattr(args, 'annotations', {})\\n additional_property_messages = []\\n if not annotations:\\n return None\\n\\n for key, value in annotations.items():\\n additional_property_messages.append(\\n messages.V2Key.AnnotationsValue.AdditionalProperty(\\n key=key, value=value))\\n\\n annotation_value_message = messages.V2Key.AnnotationsValue(\\n additionalProperties=additional_property_messages)\\n\\n return annotation_value_message\",\n \"def parameter_finder(target_list, search_list, msgflag=False, exact=False):\\n target_list = [x.lower() for x in target_list]\\n\\n indexes = []\\n\\n if isinstance(search_list, str):\\n cont = 0\\n search_list = search_list.lower()\\n for t in target_list:\\n if exact == False and search_list in t:\\n indexes.append(cont)\\n elif exact == True and search_list == t:\\n indexes.append(cont)\\n cont += 1\\n if isinstance(search_list, list):\\n search_list = [x.lower() for x in search_list]\\n\\n for s in search_list:\\n s = str(s)\\n for cont, t in enumerate(target_list):\\n if exact == False and s in t:\\n print((s, t))\\n indexes.append(cont)\\n elif exact == True and s == t:\\n print((s, t))\\n indexes.append(cont)\\n\\n if msgflag == True:\\n length = len(indexes)\\n if length > 1: print(\\\"There were several ocurrences\\\")\\n if length == 0: print(\\\"No ocurrences found\\\")\\n\\n return indexes\",\n \"def search(self, term):\",\n \"def getannotationstrings(cann):\\n cdesc = ''\\n if cann['description']:\\n cdesc += cann['description'] + ' ('\\n if cann['annotationtype'] == 'diffexp':\\n chigh = []\\n clow = []\\n call = []\\n for cdet in cann['details']:\\n if cdet[0] == 'all':\\n call.append(cdet[1])\\n continue\\n if cdet[0] == 'low':\\n clow.append(cdet[1])\\n continue\\n if cdet[0] == 'high':\\n chigh.append(cdet[1])\\n continue\\n cdesc += ' high in '\\n for cval in chigh:\\n cdesc += cval + ' '\\n cdesc += ' compared to '\\n for cval in clow:\\n cdesc += cval + ' '\\n cdesc += ' in '\\n for cval in call:\\n cdesc += cval + ' '\\n elif cann['annotationtype'] == 'isa':\\n cdesc += ' is a '\\n for cdet in cann['details']:\\n cdesc += 'cdet,'\\n elif cann['annotationtype'] == 'contamination':\\n cdesc += 'contamination'\\n else:\\n cdesc += cann['annotationtype'] + ' '\\n for cdet in cann['details']:\\n cdesc = cdesc + ' ' + cdet[1] + ','\\n return cdesc\",\n \"def search(self, text, location=\\\"\\\"):\\n return [\\n obj.name[len(location) + 1 : -3] for obj in self._file_model.search(text) if obj.name.startswith(location)\\n ]\",\n \"def subStringMatchOneSub(key,target):\\n allAnswers = ()\\n for miss in range(0,len(key)):\\n # miss picks location for missing element\\n # key1 and key2 are substrings to match\\n key1 = key[:miss]\\n key2 = key[miss+1:]\\n #print 'breaking key',key,'into',key1,key2\\n # match1 and match2 are tuples of locations of start of matches\\n # for each substring in target\\n match1 = subStringMatchExact(target,key1)\\n match2 = subStringMatchExact(target,key2)\\n # when we get here, we have two tuples of start points\\n # need to filter pairs to decide which are correct\\n filtered = constrainedMatchPair(match1,match2,len(key1))\\n allAnswers = allAnswers + filtered\\n #print 'match1',match1\\n #print 'match2',match2\\n #print 'possible matches for',key1,key2,'start at',filtered\\n return allAnswers\",\n \"def subStringMatchOneSub(key,target):\\r\\n allAnswers = ()\\r\\n for miss in range(0,len(key)):\\r\\n # miss picks location for missing element\\r\\n # key1 and key2 are substrings to match\\r\\n key1 = key[:miss]\\r\\n key2 = key[miss+1:]\\r\\n print 'breaking key',key,'into',key1,key2\\r\\n # match1 and match2 are tuples of locations of start of matches\\r\\n # for each substring in target\\r\\n match1 = subStringMatchExact(target,key1)\\r\\n match2 = subStringMatchExact(target,key2)\\r\\n # when we get here, we have two tuples of start points\\r\\n # need to filter pairs to decide which are correct\\r\\n filtered = constrainedMatchPair(match1,match2,len(key1))\\r\\n allAnswers = allAnswers + filtered\\r\\n print 'match1',match1\\r\\n print 'match2',match2\\r\\n print 'possible matches for',key1,key2,'start at',filtered\\r\\n return allAnswers\",\n \"def find_key(dic, val): \\n return [k for k, v in dic.iteritems() if re.search(v, val)]\",\n \"def _od_substrings(offsets_dict):\\n return sorted(offsets_dict[offsets_dict.keys()[0]].keys())\",\n \"def substring_indexes(substring, string):\\n last_found = -1 # Begin at -1 so the next position to search from is 0\\n while True:\\n # Find next index of substring, by starting after its last known position\\n last_found = string.find(substring, last_found + 1)\\n if last_found == -1:\\n break # All occurrences have been found\\n yield last_found\",\n \"def find_strings(line, result):\\n\\n idx = 0\\n while idx != -1:\\n idx = extract_string(line, idx, result)\",\n \"def doFindAllMatching(self, str):\\n matches = []\\n for value in self.doId2do.values():\\n if re.search(str,repr(value)):\\n matches.append(value)\\n return matches\",\n \"def subStringMatchOneSub(key,target):\\n allAnswers = ()\\n for miss in range(0,len(key)):\\n # miss picks location for missing element\\n # key1 and key2 are substrings to match\\n key1 = key[:miss]\\n key2 = key[miss+1:]\\n print 'breaking key',key,'into',key1,key2\\n # match1 and match2 are tuples of locations of start of matches\\n # for each substring in target\\n match1 = subStringMatchExact(target,key1)\\n match2 = subStringMatchExact(target,key2)\\n # when we get here, we have two tuples of start points\\n # need to filter pairs to decide which are correct\\n filtered = constrainedMatchPair(match1,match2,len(key1))\\n allAnswers = allAnswers + filtered\\n print 'match1',match1\\n print 'match2',match2\\n print 'possible matches for',key1,key2,'start at',filtered\\n return allAnswers\",\n \"def match_all_cui(s,max_len = 10, Eterm_cui = Eterm_cui):\\n if len(s) == 0: \\n return []\\n sub_label = np.zeros(len(s),dtype = 'int')\\n location_term = {}\\n i = 0\\n while i < len(s):\\n for j in range(max_len+1,0,-1):\\n temp = ' '.join(s[i:i+j])\\n if temp in Eterm_cui:\\n sub_label[i:i+j] = 1\\n location_term[i] = [Eterm_cui[temp]]\\n break#matched maximum string, so break\\n i += j\\n output = []\\n for i in range(len(s)):\\n if sub_label[i] == 0:#no match\\n output += [s[i]]\\n elif i in location_term:\\n for cui in location_term[i][: :-1]:\\n output += [cui]\\n return output\",\n \"def search(self, sstrings, **kwargs):\\n if self._info is None or self._info is False:\\n self._info = self.allinfo()\\n return _search(self._info, sstrings, **kwargs)\",\n \"def subStringMatchOneSub(key,target):\\n allAnswers = ()\\n for miss in range(0,len(key)):\\n # miss picks location for missing element\\n # key1 and key2 are substrings to match\\n key1 = key[:miss]\\n key2 = key[miss+1:]\\n #print 'breaking key',key,'into',key1,key2\\n # match1 and match2 are tuples of locations of start of matches\\n # for each substring in target\\n match1 = subStringMatchExact(target,key1)\\n match2 = subStringMatchExact(target,key2)\\n # when we get here, we have two tuples of start points\\n # need to filter pairs to decide which are correct\\n # and we need to remove the starting points of perfect matchs.\\n perfect_matches = subStringMatchExact(target, key)\\n filtered = constrainedMatchPair(match1,match2,len(key1), perfect_matches)\\n\\n allAnswers = allAnswers + filtered\\n #print 'match1',match1\\n #print 'match2',match2\\n #print 'possible matches for',key1,key2,'start at',filtered\\n return allAnswers\",\n \"def get_patient(drs):\\n for line in drs:\\n if line.strip().startswith('sem'):\\n datalist = line.split(':')\\n for word in datalist: \\n if word.count('patient') > 0:\\n variable = word[6:7]\\n for word in datalist:\\n if word.startswith('pred({0}'.format(variable)):\\n return word.split(',')[1]\",\n \"def get_substring_offsets(string, substring):\\n offsets = []\\n ofs = -1\\n while True:\\n ofs = string.find(substring, ofs+1)\\n if ofs < 0:\\n break\\n offsets.append(ofs)\\n return set(offsets)\",\n \"def search_by_contains(self, tl):\\n print(\\\"Search by string\\\")\\n string = input(\\\"Please enter search string: \\\")\\n return tl.findall_contains(string)\",\n \"def subStringMatchExact(target,key,length):\\r\\n index = find(target,key)\\r\\n if index < 0:\\r\\n return ()\\r\\n else:\\r\\n matches = subStringMatchExact(target[index+len(key):len(target)],key,length)\\r\\n index += (length - len(target))\\r\\n matches += (index,)\\r\\n print matches\\r\\n return matches\",\n \"def mutt_search(self, term):\\n attrs = (\\\"email_address\\\", \\\"name\\\", \\\"otherinfo\\\", \\\"extrainfo\\\")\\n ret = list(\\n filter(lambda aitem: any(\\n term in getattr(aitem, attr, \\\"\\\") for attr in attrs\\n ), self.addresses)\\n )\\n return ret\",\n \"def getSpecific(self, keyword, key):\",\n \"def sparse_it(self, query : str) -> Dict[str, int]:\\n return matchingStrings(self.sentence,query)\",\n \"def _filter_search_values(key: str, values: list, collection: list):\\n return_data = []\\n for item in collection:\\n if any(val in values for val in item[key]):\\n return_data.append(item)\\n return return_data\",\n \"def get_value(self) -> Dict[str, any]:\",\n \"def subStringMatchExact(target,key):\\r\\n index = find(target,key)\\r\\n #print 'here',target,key,index\\r\\n if index < 0 or len(key) <= 0 or len(target) <= 0:\\r\\n return ()\\r\\n matches = subStringMatchExact(target[index+len(key):len(target)],key)\\r\\n offset = index + len(key)\\r\\n temp_matches = ()\\r\\n #print matches\\r\\n if matches:\\r\\n for x in range(0, len(matches)) :\\r\\n temp_matches += ((matches[x] + offset),)\\r\\n #matches.insert(0,index)\\r\\n temp_matches = (index,) + temp_matches\\r\\n return temp_matches\",\n \"def test_search_subnode_2_value(self):\\n\\n lista = []\\n for (n, _) in self.parser.search(self.xml, 'subnodes@ref=2'):\\n for (_, v2) in self.parser.search(n, 'subnode'):\\n lista.append(v2)\\n self.assertEqual(lista, ['S2.1', 'S2.2'])\",\n \"def searchGlossary(self,keyword):\\n\\t\\twords = []\\n\\n\\t\\tfor letter in glossary:\\n\\t\\t\\tfor word in glossary[letter]:\\n\\t\\t\\t\\tprint word.keys()[0]\\n\\t\\t\\t\\tif keyword.lower() in word.keys()[0].lower():\\n\\t\\t\\t\\t\\twords.append(word)\\n\\n\\t\\treturn words\",\n \"def search_features_str(obs, VARIABLES):\\n \\n matched_features = []\\n feature_count = sum([obs.data[i].value for i in range(len(obs.data))])\\n \\n if debugmode:\\n obs_value_list = [obs.data[i].value for i in range(len(obs.data))]\\n feature_index = [i for i, j in enumerate(obs_value_list) if j != 0] # matched features index (non zero counters)\\n for index in feature_index:\\n fName = obs.data[index].fName\\n fVariable = obs.data[index].fVariable\\n pos = VARIABLES[fVariable]['where']\\n matched_features.append({fName:pos})\\n \\n return feature_count, matched_features\",\n \"def doFindAll(self, str):\\n matches = []\\n for value in self.doId2do.values():\\n if repr(value).find(str) >= 0:\\n matches.append(value)\\n return matches\",\n \"def find_entries(citation_string):\\n for idx, token in enumerate(citation_string):\\n if token == \\\"@\\\":\\n yield idx\",\n \"def retrieve_meta(meta_text):\\n\\n with open(meta_text) as f:\\n meta = f.readlines()\\n matchers = ['RADIANCE_MULT_BAND_10', 'RADIANCE_ADD_BAND_10', 'K1_CONSTANT_BAND_10', 'K2_CONSTANT_BAND_10']\\n matching = [process_string(s) for s in meta if any(xs in s for xs in matchers)]\\n return matching\",\n \"def substring_indexes(substring, string):\\n last_found = -1 # Begin at -1 so the next position to search from is 0\\n while True:\\n # Find next index of substring, by starting after its last known position\\n last_found = string.find(substring, last_found + 1)\\n if last_found == -1:\\n break # All occurrences have been found\\n yield last_found + (len(substring) - 1) # Return for iterator and make index be at the end\",\n \"def test_get_substrings_all(self):\\n\\n ans = [s.value() for s in self.sf.get_substrings(0, False)]\\n\\n expected_values = [(0, 1, 2, 3, 4, 5), (0, 1, 2, 3, 4), (1, 2, 3, 4, 5), (1, 2, 3, 4), \\\\\\n (2, 3, 4, 5), (2, 3, 4), (3, 4, 5), (3, 4), (4, 5), (4,), (5,)]\\n\\n self.assertEqual(ans, expected_values)\",\n \"def global_matches(self, text):\\n\\n matches = []\\n n = len(text)\\n\\n for list in [ self.namespace ]:\\n for word in list:\\n if word[:n] == text:\\n matches.append(word)\\n\\n return matches\",\n \"def get_values(in_file, out_file, keyword1):\\n return_data = 0\\n str_data = ' '\\n write_data = ''\\n kw_position = -1\\n next_row = 0\\n occurences = 0\\n start_position = 0\\n count1 = 0\\n count2 = 0\\n i = 0\\n try:\\n with open(in_file, 'rt', encoding='utf-16-le') as fi:\\n for line in fi: #For each line do the following\\n str_data = line\\n if next_row == 1: #Means that a valid keyword was found in the previous row\\n i = 0\\n count1 = 0\\n count2 = 0\\n while i < len(str_data): #Iterate until the amount of commas is reached, we know the amount of commas from the previous row\\n i = i+1\\n if str_data[i-1] == \\\",\\\": #Looks for the commas and count them with their positions in the string\\n count1 = count1 + 1\\n count2 = count2 + 1\\n if count1 == occurences: #The keyword begin position is reached, get the position in the string\\n start_position = i-1\\n if count2 == (occurences + 1): #The keyword end position is reached, get the position in the string\\n end_position = i-1\\n i = len(str_data)\\n start_position = start_position + 1 #Else the first comma is also copied for output\\n if kw_position <= 2: #this part for when the keyword is at the beginning without a comma in front of it\\n start_position = start_position - 1\\n print('Value = ', str_data[start_position:end_position])\\n write_data = str_data[start_position:end_position] + '\\\\n' #Build the data string with a new line appended to it\\n with open(out_file, 'at') as fo: #Write the data string to a file\\n fo.seek(0,2)\\n fo.write(write_data)\\n fo.close()\\n next_row = 0\\n kw_position = str_data.find(keyword1) #Check the keyword position in the line, -1 if not found\\n if kw_position > -1: #If the keyword is found in the line\\n next_row = 1 #set the next row to be processed for the keyword\\n occurences = str_data.count(',', 0, kw_position) #Check how many comma's it is up to the keyword\\n except IOError:\\n print(\\\"Error in reading/writing file.\\\")\\n return_data = 2\\n else:\\n print('Operation completed successfully.')\\n return_data = 1\\n finally:\\n print(\\\"done\\\")\\n return return_data\",\n \"def construct_search(barcodes, args):\\n\\tsearch = []\\n\\tfor i, set in enumerate(barcodes):\\n\\t\\tname = list(barcodes[i].keys())[0]\\n\\t\\t\\n\\t\\t# if type is variable, construct regex to match \\n\\t\\tif barcodes[i][name]['type'] == 'variable':\\n\\t\\t\\t\\n\\t\\t\\t# add type, name, and bool specifiying if we want to translate\\n\\t\\t\\tsearch_dict = {'type':'variable'}\\n\\t\\t\\tsearch_dict['name'] = name\\n\\t\\t\\tsearch_dict['trans'] = barcodes[i][name]['translate']\\n\\t\\t\\t\\n\\t\\t\\t# if we allow mismatches\\n\\t\\t\\tif 'mismatches' in barcodes[i][name]:\\n\\t\\t\\t\\tmismatches = barcodes[i][name]['mismatches']\\n\\t\\t\\telse:\\n\\t\\t\\t\\tmismatches = 0\\n\\t\\t\\t\\n\\t\\t\\t# construct regex for searching\\n\\t\\t\\tsearch_dict['forward'] = construct_variable_regex(barcodes[i][name]['before'], barcodes[i][name]['after'], mismatches)\\n\\t\\t\\t\\n\\t\\t\\t#search_dict['forward'] = f\\\"{barcodes[i][name]['before']}(.+){barcodes[i][name]['after']}\\\"\\n\\t\\t\\tsearch.append(search_dict)\\n\\t\\t\\t\\n\\t\\t# if type is constant, we need to check if we are allowing mismatches or not\\n\\t\\telif barcodes[i][name]['type'] == 'constant':\\n\\t\\t\\t# if number of mismatches is specified\\n\\t\\t\\tsearch_dict = create_barcodes_search_dict(barcodes[i][name], args)\\n\\t\\t\\tsearch_dict['name'] = name\\n\\t\\t\\tsearch.append(search_dict)\\n\\t\\t\\t\\t\\t\\t\\n\\treturn search\",\n \"def text_search():\\n existing_fields = self.attr_name_map[object_class]\\n text = \\\"%{}%\\\".format(exp[\\\"text\\\"])\\n p = lambda f: f.ilike(text)\\n return or_(*(\\n with_key(field, p)\\n for field in fields\\n if field in existing_fields\\n ))\",\n \"def generate_suggestions(search_string):\\n\\n root = read_data_model('data/data_model.pkl')\\n with ListStream() as x:\\n root.search(search_string, '')\\n print [s.strip('\\\\n') for s in x.data if s != '\\\\n']\",\n \"def kmp_search(full_str, sub_str):\\n n, m = len(full_str), len(sub_str)\\n result = []\\n pi = get_partial_match(sub_str)\\n begin, matched = 0, 0\\n while begin <= (n - m):\\n if matched < m and full_str[begin + matched] == sub_str[matched]:\\n matched += 1\\n if matched == m:\\n result.append(begin)\\n else:\\n if matched == 0:\\n begin += 1\\n else:\\n begin += (matched - pi[matched - 1])\\n matched = pi[matched - 1]\\n return result\",\n \"def choose_variant_annotation(csq_string, variant_annotation_rank_dict, gene_ix, conseq_ix):\\n minrank = len(variant_annotation_rank_dict)\\n gene_id = 'NA'\\n conseq = 'NA'\\n\\n for tr in csq_string.split(','):\\n annots = tr.split('|')\\n for v in annots[conseq_ix].split('&'):\\n if v in variant_annotation_rank_dict:\\n r = variant_annotation_rank_dict[v]\\n if r<minrank:\\n minrank = r\\n gene_id = annots[gene_ix]\\n conseq = v\\n return gene_id, conseq\",\n \"def find(self, str_tags=None, suffixed=False):\\n if not str_tags:\\n str_tags = VAR_SUFFIXES\\n else:\\n if not isinstance(str_tags, list): str_tags = [str_tags]\\n found = []\\n variables = self.variables()\\n for v in variables:\\n for str_tag in str_tags:\\n if suffixed:\\n if v.endswith(str_tag): found.append(v)\\n else:\\n if str_tag in v: found.append(v)\\n return found\",\n \"def find_string_in_control(self, control: cat.Control, seek_str: str) -> List[Tuple[str, str]]:\\n hits: List[Tuple[str, str]] = []\\n if control.parts:\\n for part in control.parts:\\n hits.extend(self._find_string_in_part(control.id, part, seek_str))\\n return hits\",\n \"def split_search(self, value: str, adapter: str = AGG_ADAPTER_NAME) -> Tuple[str, List[str]]:\\n search = value.strip().lower()\\n\\n # Problem are fields containing \\\":\\\" from adapters that populate dynamic fields\\n # PBUG: special check for 'custom attributes' coming from esx adapter.\\n if \\\":\\\" in search and 'custom attributes' not in search:\\n adapter_split, field = [x.strip() for x in search.split(\\\":\\\", 1)]\\n if not adapter_split:\\n adapter_split = adapter\\n else:\\n field = search\\n adapter_split = adapter\\n qual_check = re.match(r\\\"adapters_data\\\\.(.*?)\\\\.\\\", field)\\n if qual_check and len(qual_check.groups()) == 1:\\n adapter_split = qual_check.groups()[0]\\n\\n adapter_split = strip_right(obj=adapter_split.lower().strip(), fix=\\\"_adapter\\\")\\n\\n fields = split_str(\\n obj=field,\\n split=\\\",\\\",\\n strip=None,\\n do_strip=True,\\n lower=True,\\n empty=False,\\n )\\n\\n if not fields:\\n raise ApiError(f\\\"No fields provided in {value!r}, format must be 'adapter:field'\\\")\\n return adapter_split, fields\",\n \"def contains(self, searchstr: str):\\n for x in self.sa:\\n if searchstr in x:\\n return True\\n pass\",\n \"def extract_strings(f):\\n strings = re.findall(strregex,f)\\n return strings\",\n \"def get_strings(\\n self,\\n size: Union[int, Tuple[int, int]],\\n feature: Union[str, Iterable[str]] = None,\\n ) -> List[str]:\\n query = self._prepare_query(size, feature)\\n return [\\n document['_source']['term']\\n for document in self._db.get(query)['hits']['hits']\\n ]\",\n \"def search(self, searchString):\\n resultsDict = {}\\n\\n\\n\\n #-------------------- \\n # Projects, subjects, experiments\\n #-------------------- \\n levelTags = {}\\n levelTags['projects'] = ['ID', \\n 'secondary_ID',\\n 'name', 'pi_firstname', \\n 'pi_lastname', \\n 'description']\\n levelTags['subjects'] = ['ID', 'label']\\n levelTags['experiments'] = ['ID', 'label']\\n\\n\\n\\n #-------------------- \\n # Looping through all of the levels,\\n # constructing a searchQuery for each based\\n # on the relevant columns.\\n #-------------------- \\n levels = ['projects', 'subjects', 'experiments']\\n for level in levels:\\n resultsDict[level] = []\\n for levelTag in levelTags[level]:\\n searchStr = '/%s?%s=*%s*'%(level, levelTag, searchString)\\n #\\n # Experiments: only search folders with images\\n #\\n if level == 'experiments':\\n searchStr2 = searchStr + '&xsiType=xnat:mrSessionData'\\n searchStr = searchStr + '&xsiType=xnat:petSessionData'\\n resultsDict[level] = resultsDict[level] + \\\\\\n self.__getJson(searchStr2)\\n resultsDict[level] = resultsDict[level] + \\\\\\n self.__getJson(searchStr)\\n\\n\\n\\n return resultsDict\",\n \"def find_matches(self, sentence):\\n # Split the sentence in words (tokens)\\n tokens = tokenize(sentence)\\n # Define a list to hold the matches\\n matches = []\\n # Go over all the words in the sentence\\n for i in xrange(len(tokens)):\\n current_store = self.store_dict\\n # Go over all the words starting from the current word\\n for j in xrange(i, len(tokens)):\\n word = tokens[j]\\n if word in current_store:\\n # If the word is in the current dictionary, update this current dictionary,\\n # and check if there is an _end symbol\\n current_store = current_store[word]\\n if self._end in current_store:\\n # If there is an _end symbol, add the current match to the list of matches.\\n matches.append(current_store[self._end])\\n else:\\n # Break and start again with the next word if the word is not \\n # in the current dictionary\\n break\\n return matches\",\n \"def get_proposal_terms(search, tokens):\\n\\tif isinstance(tokens, str):\\n\\t\\ttokens = [tokens]\\n\\tfound = search.get(tokens[0], {})\\n\\tif found:\\n\\t\\tif tokens[1:]:\\n\\t\\t\\tfound = get_proposal_terms(found, tokens[1:])\\n\\t\\telse:\\n\\t\\t\\tfound = []\\n\\telse:\\n\\t\\ttoken_0 = tokens[0]\\n\\t\\tfound = [term for term in search.keys() if term.startswith(token_0) and term != token_0]\\n\\treturn found\",\n \"def consensus_scan(self, fa):\\n regexp = \\\"\\\".join([\\\"[\\\" + \\\"\\\".join(self.iupac[x.upper()]) + \\\"]\\\" for x in self.to_consensusv2()])\\n p = re.compile(regexp)\\n matches = {}\\n for name,seq in fa.items():\\n matches[name] = [] \\n for match in p.finditer(seq):\\n middle = (match.span()[1] + match.span()[0]) / 2\\n matches[name].append(middle)\\n return matches\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5903146","0.5488121","0.5460287","0.5396356","0.53472704","0.5338512","0.53332084","0.5275697","0.5245533","0.5171115","0.51687026","0.5167059","0.5165257","0.51592106","0.5158753","0.5154511","0.5152063","0.5150403","0.5129545","0.51103365","0.51068866","0.5091393","0.5087708","0.5074303","0.5064305","0.5060551","0.50573236","0.50471854","0.5032215","0.5031321","0.5001147","0.49822938","0.49757496","0.49717897","0.49697685","0.49632832","0.49616504","0.49616504","0.49567163","0.49444896","0.49373472","0.49317494","0.49315128","0.49313876","0.4930502","0.49297658","0.49210334","0.49152187","0.49122915","0.49049377","0.48907033","0.48904964","0.4889447","0.48764873","0.4864642","0.48641697","0.48612937","0.48557398","0.4855384","0.48446384","0.48406255","0.48405725","0.4817583","0.4812958","0.4812291","0.48080388","0.4777898","0.4772051","0.47649178","0.47619638","0.47572526","0.47561377","0.4754703","0.47516322","0.47465986","0.47404","0.47294694","0.47273502","0.47262883","0.47238547","0.47234008","0.4714873","0.47027162","0.4695483","0.46930614","0.46923605","0.4688668","0.46884668","0.4680355","0.46797636","0.4675973","0.46643156","0.46607566","0.46571106","0.46568918","0.4651023","0.464984","0.46493977","0.4646899","0.46383193"],"string":"[\n \"0.5903146\",\n \"0.5488121\",\n \"0.5460287\",\n \"0.5396356\",\n \"0.53472704\",\n \"0.5338512\",\n \"0.53332084\",\n \"0.5275697\",\n \"0.5245533\",\n \"0.5171115\",\n \"0.51687026\",\n \"0.5167059\",\n \"0.5165257\",\n \"0.51592106\",\n \"0.5158753\",\n \"0.5154511\",\n \"0.5152063\",\n \"0.5150403\",\n \"0.5129545\",\n \"0.51103365\",\n \"0.51068866\",\n \"0.5091393\",\n \"0.5087708\",\n \"0.5074303\",\n \"0.5064305\",\n \"0.5060551\",\n \"0.50573236\",\n \"0.50471854\",\n \"0.5032215\",\n \"0.5031321\",\n \"0.5001147\",\n \"0.49822938\",\n \"0.49757496\",\n \"0.49717897\",\n \"0.49697685\",\n \"0.49632832\",\n \"0.49616504\",\n \"0.49616504\",\n \"0.49567163\",\n \"0.49444896\",\n \"0.49373472\",\n \"0.49317494\",\n \"0.49315128\",\n \"0.49313876\",\n \"0.4930502\",\n \"0.49297658\",\n \"0.49210334\",\n \"0.49152187\",\n \"0.49122915\",\n \"0.49049377\",\n \"0.48907033\",\n \"0.48904964\",\n \"0.4889447\",\n \"0.48764873\",\n \"0.4864642\",\n \"0.48641697\",\n \"0.48612937\",\n \"0.48557398\",\n \"0.4855384\",\n \"0.48446384\",\n \"0.48406255\",\n \"0.48405725\",\n \"0.4817583\",\n \"0.4812958\",\n \"0.4812291\",\n \"0.48080388\",\n \"0.4777898\",\n \"0.4772051\",\n \"0.47649178\",\n \"0.47619638\",\n \"0.47572526\",\n \"0.47561377\",\n \"0.4754703\",\n \"0.47516322\",\n \"0.47465986\",\n \"0.47404\",\n \"0.47294694\",\n \"0.47273502\",\n \"0.47262883\",\n \"0.47238547\",\n \"0.47234008\",\n \"0.4714873\",\n \"0.47027162\",\n \"0.4695483\",\n \"0.46930614\",\n \"0.46923605\",\n \"0.4688668\",\n \"0.46884668\",\n \"0.4680355\",\n \"0.46797636\",\n \"0.4675973\",\n \"0.46643156\",\n \"0.46607566\",\n \"0.46571106\",\n \"0.46568918\",\n \"0.4651023\",\n \"0.464984\",\n \"0.46493977\",\n \"0.4646899\",\n \"0.46383193\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.576712"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20164,"cells":{"query":{"kind":"string","value":"Counts in how many edges each annotation appears in a graph"},"document":{"kind":"string","value":"def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def edgecount(self):\n\n raise NotImplementedError","def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2","def edge_count(self) -> int:\n return int(self.graph_tuple_stats.edge_count or 0)","def get_annotation_count(self):\n return self._num_annos","def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2","def num_of_edge(self):\n try:\n return self.edges\n except:\n print(\"ERROR: No graph exists\")","def _num_edges(self):\n return len(self._eid2partid)","def num_edges(self):\n return sum(1 for _ in self.iteredges())","def return_num_edges(self):\n return sum(map(lambda x: len(x),self.__adj))","def countEdges(self):\n n = 0\n for (hub, table) in self.totsupport.iteritems():\n n += len(table)\n return n","def _number_of_edges(self):\n if self._edges is None:\n return 0\n return len(self._edges)","def street_segment_count(Gu):\n if nx.is_directed(Gu): # pragma: no cover\n msg = \"`Gu` must be undirected\"\n raise ValueError(msg)\n return len(Gu.edges)","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )","def countEdges(self):\n return numpy.count_nonzero(self.supportArray) / 2","def num_edges(self):\r\n return len(self.__generate_edges())","def edge_count(self):\r\n return int(sum(self.degree(node) for node in range(self.size))/2)","def num_edges(self):\n return sum(len(v.adj) for v in self.vertices.values())","def _num_edges(self):\n return int(self._edge_map[-1])","def countEdges(self):\n s1 = self.DBcurs.execute(\"SELECT count(*) FROM edges\")\n data = s1.fetchone()\n if data:\n return data[0]\n else:\n return 0","def get_no_of_annotations(database, label, train_vids_all):\n count = 0\n for vid in train_vids_all:\n for ann in database[vid]['annotations']:\n if ann['label'] == label:\n count += 1\n return count","def edge_count(adjList):\n edges = {}\n for id, neigh in enumerate(adjList):\n for n in neigh:\n edges[max(n, id), min(n, id)] = id\n\n return len(edges)","def control_edge_count(self) -> int:\n return int(self.graph_tuple_stats.control_edge_count or 0)","def Nedges(self):\n return len(self.edges)","def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):\n source_filter = keep_node_permissive if source_filter is None else source_filter\n target_filter = keep_node_permissive if target_filter is None else target_filter\n\n return Counter(\n data[ANNOTATIONS][annotation]\n for u, v, data in graph.edges_iter(data=True)\n if edge_has_annotation(data, annotation) and source_filter(graph, u) and target_filter(graph, v)\n )","def edge_count(self) -> int:\n return self._n_edges","def num_edges_rows(graph):\n return len(graph.graph.edges), len(graph.graph.nodes)","def data_edge_count(self) -> int:\n return int(self.graph_tuple_stats.data_edge_count or 0)","def number_of_edges(self) -> int:\n return self.graph.number_of_edges()","def EdgesCount(self):\n return len(self.edges)","def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))","def count_nodes(self, term=None, labels: istr = None) -> int:","def edge_count(self):\n total = sum(len(self._outgoing[v]) for v in self._outgoing)\n # for undirected graphs, make sure not to double-count edges\n return total if self.is_directed() else total // 2","def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))","def num_edges(self):\n return self._top_exp.number_of_edges()","def size(self):\n return len(self.edges())","def count_nodes(self, term=None, labels: istr = None):","def count(self):\n\t\treturn len(list(self.nodes))","def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses","def node_count(self) -> int:\n return int(self.graph_tuple_stats.node_count or 0)","def ngraphs(self):\n return len(self.__graph_list)","def call_edge_count(self) -> int:\n return int(self.graph_tuple_stats.call_edge_count or 0)","def __len__(self) -> int:\r\n return len(self._edges)","def num_nodes(g):\n return len(g.keys())","def Test_NumEdges(Graph_MD):\n N_Edges = float(Graph_MD.number_of_edges())\n\n return N_Edges","def compute_num_nodes(graph):\n return len(graph.keys()) # return the number of nodes in the graph","def number_of_connections(self, asn):\n customer_count = 0\n provider_count = 0\n peer_count = 0\n\n for neighbor in nx.all_neighbors(self, asn):\n edge_data = self.get_edge_data(asn, neighbor)\n if edge_data[\"relationship\"] == -1 and edge_data[\"as1\"] == asn:\n customer_count += 1\n elif edge_data[\"relationship\"] == -1 and edge_data[\"as2\"] == asn:\n provider_count += 1\n elif edge_data[\"relationship\"] == 0:\n peer_count += 1\n return customer_count, provider_count, peer_count","def num_links(self):\n count=0.0\n for cluster in self.clusters:\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\n numberofmembers=self.clusters[cluster].number_of_members\n count+=numberofmembers\n return count","def e_size(self) -> int:\n return self.edges_on_graph","def num_edges(self):\n return self._ll_tree.get_num_edges()","def num_of_subgraphs(self):\n \n G = self.to_undirected_graph()\n \n count = G.num_subgraph()\n \n print('The number of disconnected components in the graph is ', count)","def count_unvisited(data):\n count = sum(n.count(\"n\") for n in data)\n return count","def getCounts(self):\n ret = [0]*len(self.numToLabel)\n for block in self.blocks:\n for label in block[1]: ret[label] += 1\n return ret","def _count_bipartite_edges(G, X, Y):\n cpt = 0\n for edge in G.edges:\n v1 = edge.v1\n v2 = edge.v2\n if (X.__contains__(v1) and Y.__contains__(v2)) or (X.__contains__(v2) and Y.__contains__(v1)):\n cpt += 1\n return cpt","def guess_num_nodes_from(edgelist):\n return np.max(edgelist) + 1","def num_edges(graph1: list, graph2: list):\n check1 = 0\n check2 = 0\n for row, _ in enumerate(graph1):\n for column, _ in enumerate(graph1[row]):\n if graph1[row][column] == 1:\n check1 += 1\n if graph2[row][column] == 1:\n check2 += 1\n return check1 == check2","def count_nodes(self):\n\t\treturn self.__count_nodes(self)","def get_indegrees(graph: Graph):\n transpose = get_transpose_graph(graph)\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}","def number_of_indirect_deviation_edges(self):\n return len(list(self.indirect_deviation_edges()))","def count(seats: List[str]) -> int:\n # Map dimensions\n m = len(seats)\n n = len(seats[0]) if m else 0\n \n count = 0\n \n # Count locations filled with \"#\"\n for i in range(m):\n for j in range(n):\n if seats[i][j] == \"#\":\n count += 1\n\n return count","def fill_count(nid):\n n_edges = G.subgraph(G.neighbors(nid)).number_of_edges()\n deg = G.degree[nid]\n n_fill = deg*(deg-1)//2 - n_edges\n return n_fill","def num_edge_features(self):\n return self[0].num_edge_features","def count():","def init_inbound_counts(nodes, edges):\n inbound_counts = {}\n for node in nodes:\n inbound_counts[node] = 0\n for e in edges:\n inbound_counts[e[1]] = inbound_counts[e[1]] + 1\n return inbound_counts","def num_labels(self) -> int:\n raise NotImplementedError","def edge_length_total(G):\n return sum(d[\"length\"] for u, v, d in G.edges(data=True))","def get_node_count(self) -> Iterable:\n return self._g.V().count().toList()[0]","def get_nodes_pixel_count(self):\n sum_count = self.pixel_count\n for i in range(8):\n node = self.children[i]\n if node:\n sum_count += node.pixel_count\n return sum_count","def get_node_count(self) -> Iterable:\n return len([i for i in self.all_nodes_as_iterable()])","def test_count_neighbors(self):\n m, n = 5, 5\n k, p = 0.2, 0.7\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\n C = ConwayModel(m, n, k, p, agents)\n\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\n result = C.count_neighbors(to_count)\n self.assertTrue(np.all(expected == result))","def numnems(self):\n count = 0\n for o in self._objs.values():\n count += len(o.netifs())\n return count","def get_num_edges(self):\n\n return self._graph_state.get_num_edges()","def hypergraph_common_edges(u, v, hypergraph):\n total = 0\n for e in hypergraph.edges():\n if u in e.elements and v in e.elements:\n total += 1\n return total","def count_indications(self) -> int:\n return self._count_model(Indication)","def size(self):\n num_vert = 0\n num_edg = 0\n for vertex in self.vertices():\n num_vert += 1\n num_edg += len(self.neighbors(vertex))\n return (num_vert, num_edg)","def gal_count(clusters):\n sum = 0\n for x in clusters:\n sum += x.ngal\n return sum","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def get_number_of_spectra(graph):\n return sum([graph.node[c][\"size\"] for c in graph.nodes])","def _num_conn_comp(graph):\n\n return nx.number_connected_components(graph)","def number_of_deviation_edges(self):\n return len(list(self.deviation_edges()))","def count_segments(markers) -> int:\n cnt = Counter()\n for row in markers:\n cnt.update(row)\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\n del n_cnt[1]\n del n_cnt[-1]\n return len(n_cnt.keys())","def ir_count(self) -> int:\n return int(self.graph_tuple_stats.ir_count or 0)","def number_of_direct_deviation_edges(self):\n return len(list(self.direct_deviation_edges()))","def ndim(self):\n return len(self.edges)","def size(self):\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))","def get_gini(self, rows):\n label_count = defaultdict(int)\n total_count = 0\n for row in rows:\n label = row[self.target_attribute]\n label_count[label] += 1\n total_count += 1\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])","def __len__(self) -> int:\n return len(self.graphs)","def count_edges(input_first, input_second, problem):\n\tcount = 0\n\tfor idx in xrange(len(input_first)):\n\t\tfor index in xrange(len(input_second)):\n\t\t\tif (input_first[idx], input_second[index]) in problem:\n\t\t\t\tcount += 1\n\t\t\telif (input_second[index], input_first[idx]) in problem:\n\t\t\t\tcount += 1\n\treturn count","def num_edges(self):\n return (self.n * (self.L.size() - 1) - self.num_loop_vertices()) // (1 + int(not self.variant.is_bipartite()))","def mark_as(self, label: str) -> int:\n self.label = label\n return len(self._content) // len(ANNOTATIONS)","def num_edges(self, etype: Optional[str] = None) -> int:\n if etype:\n if etype not in self.canonical_etypes:\n etype = self.get_corresponding_canonical_etype(etype)\n return self.num_edges_dict[etype]\n else:\n return self.total_number_of_edges","def neighbor_count(A):\n sum2 = lambda A, B: map2(add, A, B)\n neighbors = ((-1, -1), (-1, 0), (-1, 1),\n (0, -1), (0, 1),\n (1, -1), (1, 0), (1, 1))\n return reduce(sum2,\n map(lambda d: rotate2(A, d[0], d[1]),\n neighbors))","def number_of_trail_edges(self):\n return len(list(self.trail_edges()))","def hits(self):\n return sum(self.labels.values())","def check_number_edges(ugraph):\n directed_edges = 0\n for node in ugraph:\n directed_edges += len(ugraph[node])\n if directed_edges % 2 == 0:\n return directed_edges / 2\n else:\n return \"Not Undirected\"","def size(self):\n try:\n return len(self._adjacency_list)\n except Exception as error:\n print(f'An error occurred: {error}')","def count_classes(labels):\n class_dict = {}\n for image in labels:\n for row in image:\n for label in row:\n if label not in class_dict:\n class_dict[label] = 1\n else:\n class_dict[label] += 1\n return class_dict","def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes(arg)\n return result"],"string":"[\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def edgecount(self):\\n\\n raise NotImplementedError\",\n \"def num_edges(g):\\n total_edges_with_duplicates = sum(len(v) for v in g.values())\\n return total_edges_with_duplicates // 2\",\n \"def edge_count(self) -> int:\\n return int(self.graph_tuple_stats.edge_count or 0)\",\n \"def get_annotation_count(self):\\n return self._num_annos\",\n \"def compute_num_edges(graph):\\n # return the number of edges\\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2\",\n \"def num_of_edge(self):\\n try:\\n return self.edges\\n except:\\n print(\\\"ERROR: No graph exists\\\")\",\n \"def _num_edges(self):\\n return len(self._eid2partid)\",\n \"def num_edges(self):\\n return sum(1 for _ in self.iteredges())\",\n \"def return_num_edges(self):\\n return sum(map(lambda x: len(x),self.__adj))\",\n \"def countEdges(self):\\n n = 0\\n for (hub, table) in self.totsupport.iteritems():\\n n += len(table)\\n return n\",\n \"def _number_of_edges(self):\\n if self._edges is None:\\n return 0\\n return len(self._edges)\",\n \"def street_segment_count(Gu):\\n if nx.is_directed(Gu): # pragma: no cover\\n msg = \\\"`Gu` must be undirected\\\"\\n raise ValueError(msg)\\n return len(Gu.edges)\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def count_relations(graph):\\n return Counter(\\n data[RELATION]\\n for _, _, data in graph.edges_iter(data=True)\\n )\",\n \"def countEdges(self):\\n return numpy.count_nonzero(self.supportArray) / 2\",\n \"def num_edges(self):\\r\\n return len(self.__generate_edges())\",\n \"def edge_count(self):\\r\\n return int(sum(self.degree(node) for node in range(self.size))/2)\",\n \"def num_edges(self):\\n return sum(len(v.adj) for v in self.vertices.values())\",\n \"def _num_edges(self):\\n return int(self._edge_map[-1])\",\n \"def countEdges(self):\\n s1 = self.DBcurs.execute(\\\"SELECT count(*) FROM edges\\\")\\n data = s1.fetchone()\\n if data:\\n return data[0]\\n else:\\n return 0\",\n \"def get_no_of_annotations(database, label, train_vids_all):\\n count = 0\\n for vid in train_vids_all:\\n for ann in database[vid]['annotations']:\\n if ann['label'] == label:\\n count += 1\\n return count\",\n \"def edge_count(adjList):\\n edges = {}\\n for id, neigh in enumerate(adjList):\\n for n in neigh:\\n edges[max(n, id), min(n, id)] = id\\n\\n return len(edges)\",\n \"def control_edge_count(self) -> int:\\n return int(self.graph_tuple_stats.control_edge_count or 0)\",\n \"def Nedges(self):\\n return len(self.edges)\",\n \"def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):\\n source_filter = keep_node_permissive if source_filter is None else source_filter\\n target_filter = keep_node_permissive if target_filter is None else target_filter\\n\\n return Counter(\\n data[ANNOTATIONS][annotation]\\n for u, v, data in graph.edges_iter(data=True)\\n if edge_has_annotation(data, annotation) and source_filter(graph, u) and target_filter(graph, v)\\n )\",\n \"def edge_count(self) -> int:\\n return self._n_edges\",\n \"def num_edges_rows(graph):\\n return len(graph.graph.edges), len(graph.graph.nodes)\",\n \"def data_edge_count(self) -> int:\\n return int(self.graph_tuple_stats.data_edge_count or 0)\",\n \"def number_of_edges(self) -> int:\\n return self.graph.number_of_edges()\",\n \"def EdgesCount(self):\\n return len(self.edges)\",\n \"def count_pathologies(graph):\\n return Counter(_pathology_iterator(graph))\",\n \"def count_nodes(self, term=None, labels: istr = None) -> int:\",\n \"def edge_count(self):\\n total = sum(len(self._outgoing[v]) for v in self._outgoing)\\n # for undirected graphs, make sure not to double-count edges\\n return total if self.is_directed() else total // 2\",\n \"def count_unique_relations(graph):\\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))\",\n \"def num_edges(self):\\n return self._top_exp.number_of_edges()\",\n \"def size(self):\\n return len(self.edges())\",\n \"def count_nodes(self, term=None, labels: istr = None):\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\",\n \"def multiple_connections_histogram(synapses):\\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\\n return count_of_synapses\",\n \"def node_count(self) -> int:\\n return int(self.graph_tuple_stats.node_count or 0)\",\n \"def ngraphs(self):\\n return len(self.__graph_list)\",\n \"def call_edge_count(self) -> int:\\n return int(self.graph_tuple_stats.call_edge_count or 0)\",\n \"def __len__(self) -> int:\\r\\n return len(self._edges)\",\n \"def num_nodes(g):\\n return len(g.keys())\",\n \"def Test_NumEdges(Graph_MD):\\n N_Edges = float(Graph_MD.number_of_edges())\\n\\n return N_Edges\",\n \"def compute_num_nodes(graph):\\n return len(graph.keys()) # return the number of nodes in the graph\",\n \"def number_of_connections(self, asn):\\n customer_count = 0\\n provider_count = 0\\n peer_count = 0\\n\\n for neighbor in nx.all_neighbors(self, asn):\\n edge_data = self.get_edge_data(asn, neighbor)\\n if edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as1\\\"] == asn:\\n customer_count += 1\\n elif edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as2\\\"] == asn:\\n provider_count += 1\\n elif edge_data[\\\"relationship\\\"] == 0:\\n peer_count += 1\\n return customer_count, provider_count, peer_count\",\n \"def num_links(self):\\n count=0.0\\n for cluster in self.clusters:\\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\\n numberofmembers=self.clusters[cluster].number_of_members\\n count+=numberofmembers\\n return count\",\n \"def e_size(self) -> int:\\n return self.edges_on_graph\",\n \"def num_edges(self):\\n return self._ll_tree.get_num_edges()\",\n \"def num_of_subgraphs(self):\\n \\n G = self.to_undirected_graph()\\n \\n count = G.num_subgraph()\\n \\n print('The number of disconnected components in the graph is ', count)\",\n \"def count_unvisited(data):\\n count = sum(n.count(\\\"n\\\") for n in data)\\n return count\",\n \"def getCounts(self):\\n ret = [0]*len(self.numToLabel)\\n for block in self.blocks:\\n for label in block[1]: ret[label] += 1\\n return ret\",\n \"def _count_bipartite_edges(G, X, Y):\\n cpt = 0\\n for edge in G.edges:\\n v1 = edge.v1\\n v2 = edge.v2\\n if (X.__contains__(v1) and Y.__contains__(v2)) or (X.__contains__(v2) and Y.__contains__(v1)):\\n cpt += 1\\n return cpt\",\n \"def guess_num_nodes_from(edgelist):\\n return np.max(edgelist) + 1\",\n \"def num_edges(graph1: list, graph2: list):\\n check1 = 0\\n check2 = 0\\n for row, _ in enumerate(graph1):\\n for column, _ in enumerate(graph1[row]):\\n if graph1[row][column] == 1:\\n check1 += 1\\n if graph2[row][column] == 1:\\n check2 += 1\\n return check1 == check2\",\n \"def count_nodes(self):\\n\\t\\treturn self.__count_nodes(self)\",\n \"def get_indegrees(graph: Graph):\\n transpose = get_transpose_graph(graph)\\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}\",\n \"def number_of_indirect_deviation_edges(self):\\n return len(list(self.indirect_deviation_edges()))\",\n \"def count(seats: List[str]) -> int:\\n # Map dimensions\\n m = len(seats)\\n n = len(seats[0]) if m else 0\\n \\n count = 0\\n \\n # Count locations filled with \\\"#\\\"\\n for i in range(m):\\n for j in range(n):\\n if seats[i][j] == \\\"#\\\":\\n count += 1\\n\\n return count\",\n \"def fill_count(nid):\\n n_edges = G.subgraph(G.neighbors(nid)).number_of_edges()\\n deg = G.degree[nid]\\n n_fill = deg*(deg-1)//2 - n_edges\\n return n_fill\",\n \"def num_edge_features(self):\\n return self[0].num_edge_features\",\n \"def count():\",\n \"def init_inbound_counts(nodes, edges):\\n inbound_counts = {}\\n for node in nodes:\\n inbound_counts[node] = 0\\n for e in edges:\\n inbound_counts[e[1]] = inbound_counts[e[1]] + 1\\n return inbound_counts\",\n \"def num_labels(self) -> int:\\n raise NotImplementedError\",\n \"def edge_length_total(G):\\n return sum(d[\\\"length\\\"] for u, v, d in G.edges(data=True))\",\n \"def get_node_count(self) -> Iterable:\\n return self._g.V().count().toList()[0]\",\n \"def get_nodes_pixel_count(self):\\n sum_count = self.pixel_count\\n for i in range(8):\\n node = self.children[i]\\n if node:\\n sum_count += node.pixel_count\\n return sum_count\",\n \"def get_node_count(self) -> Iterable:\\n return len([i for i in self.all_nodes_as_iterable()])\",\n \"def test_count_neighbors(self):\\n m, n = 5, 5\\n k, p = 0.2, 0.7\\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\\n C = ConwayModel(m, n, k, p, agents)\\n\\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\\n result = C.count_neighbors(to_count)\\n self.assertTrue(np.all(expected == result))\",\n \"def numnems(self):\\n count = 0\\n for o in self._objs.values():\\n count += len(o.netifs())\\n return count\",\n \"def get_num_edges(self):\\n\\n return self._graph_state.get_num_edges()\",\n \"def hypergraph_common_edges(u, v, hypergraph):\\n total = 0\\n for e in hypergraph.edges():\\n if u in e.elements and v in e.elements:\\n total += 1\\n return total\",\n \"def count_indications(self) -> int:\\n return self._count_model(Indication)\",\n \"def size(self):\\n num_vert = 0\\n num_edg = 0\\n for vertex in self.vertices():\\n num_vert += 1\\n num_edg += len(self.neighbors(vertex))\\n return (num_vert, num_edg)\",\n \"def gal_count(clusters):\\n sum = 0\\n for x in clusters:\\n sum += x.ngal\\n return sum\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def get_number_of_spectra(graph):\\n return sum([graph.node[c][\\\"size\\\"] for c in graph.nodes])\",\n \"def _num_conn_comp(graph):\\n\\n return nx.number_connected_components(graph)\",\n \"def number_of_deviation_edges(self):\\n return len(list(self.deviation_edges()))\",\n \"def count_segments(markers) -> int:\\n cnt = Counter()\\n for row in markers:\\n cnt.update(row)\\n n_cnt = dict(takewhile(lambda x: x[1] >= 10, cnt.most_common()))\\n del n_cnt[1]\\n del n_cnt[-1]\\n return len(n_cnt.keys())\",\n \"def ir_count(self) -> int:\\n return int(self.graph_tuple_stats.ir_count or 0)\",\n \"def number_of_direct_deviation_edges(self):\\n return len(list(self.direct_deviation_edges()))\",\n \"def ndim(self):\\n return len(self.edges)\",\n \"def size(self):\\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))\",\n \"def get_gini(self, rows):\\n label_count = defaultdict(int)\\n total_count = 0\\n for row in rows:\\n label = row[self.target_attribute]\\n label_count[label] += 1\\n total_count += 1\\n return 1 - sum([np.square(float(label_count[label])/total_count) for label in label_count.keys()])\",\n \"def __len__(self) -> int:\\n return len(self.graphs)\",\n \"def count_edges(input_first, input_second, problem):\\n\\tcount = 0\\n\\tfor idx in xrange(len(input_first)):\\n\\t\\tfor index in xrange(len(input_second)):\\n\\t\\t\\tif (input_first[idx], input_second[index]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\telif (input_second[index], input_first[idx]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\treturn count\",\n \"def num_edges(self):\\n return (self.n * (self.L.size() - 1) - self.num_loop_vertices()) // (1 + int(not self.variant.is_bipartite()))\",\n \"def mark_as(self, label: str) -> int:\\n self.label = label\\n return len(self._content) // len(ANNOTATIONS)\",\n \"def num_edges(self, etype: Optional[str] = None) -> int:\\n if etype:\\n if etype not in self.canonical_etypes:\\n etype = self.get_corresponding_canonical_etype(etype)\\n return self.num_edges_dict[etype]\\n else:\\n return self.total_number_of_edges\",\n \"def neighbor_count(A):\\n sum2 = lambda A, B: map2(add, A, B)\\n neighbors = ((-1, -1), (-1, 0), (-1, 1),\\n (0, -1), (0, 1),\\n (1, -1), (1, 0), (1, 1))\\n return reduce(sum2,\\n map(lambda d: rotate2(A, d[0], d[1]),\\n neighbors))\",\n \"def number_of_trail_edges(self):\\n return len(list(self.trail_edges()))\",\n \"def hits(self):\\n return sum(self.labels.values())\",\n \"def check_number_edges(ugraph):\\n directed_edges = 0\\n for node in ugraph:\\n directed_edges += len(ugraph[node])\\n if directed_edges % 2 == 0:\\n return directed_edges / 2\\n else:\\n return \\\"Not Undirected\\\"\",\n \"def size(self):\\n try:\\n return len(self._adjacency_list)\\n except Exception as error:\\n print(f'An error occurred: {error}')\",\n \"def count_classes(labels):\\n class_dict = {}\\n for image in labels:\\n for row in image:\\n for label in row:\\n if label not in class_dict:\\n class_dict[label] = 1\\n else:\\n class_dict[label] += 1\\n return class_dict\",\n \"def countNodes(epr):\\n result = 1\\n argLst = epr.args\\n for arg in argLst:\\n result += countNodes(arg)\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8137551","0.73022085","0.6926789","0.69061303","0.68878543","0.6854445","0.67950374","0.6794573","0.67014533","0.6696235","0.6683472","0.66686267","0.6668122","0.6655918","0.6652132","0.6610412","0.65590703","0.65477306","0.6536954","0.6498154","0.64939207","0.6468801","0.64552736","0.6453763","0.6427407","0.6414381","0.6392772","0.63516915","0.63411623","0.62807196","0.62689686","0.6214962","0.62117195","0.62079644","0.61592484","0.6149697","0.61328137","0.61269367","0.61089015","0.6094596","0.6094278","0.6093638","0.608528","0.607657","0.6035048","0.603339","0.6028498","0.6020109","0.59824723","0.5960622","0.595433","0.5934617","0.59298956","0.59262687","0.59163946","0.59048265","0.5893434","0.58823365","0.58514017","0.58348525","0.58199173","0.58145905","0.57968074","0.57941794","0.5784296","0.57827336","0.5768678","0.5765457","0.5762953","0.57607174","0.5756519","0.5747187","0.5746166","0.57438624","0.5738178","0.5735377","0.5732583","0.57299197","0.57299197","0.5728584","0.57270306","0.5726033","0.5721253","0.5717768","0.5716813","0.5712355","0.5705056","0.5694271","0.5693785","0.5687486","0.56836724","0.5681856","0.56810653","0.5678886","0.5674441","0.5673957","0.56637174","0.56634414","0.5658577","0.56571954"],"string":"[\n \"0.8137551\",\n \"0.73022085\",\n \"0.6926789\",\n \"0.69061303\",\n \"0.68878543\",\n \"0.6854445\",\n \"0.67950374\",\n \"0.6794573\",\n \"0.67014533\",\n \"0.6696235\",\n \"0.6683472\",\n \"0.66686267\",\n \"0.6668122\",\n \"0.6655918\",\n \"0.6652132\",\n \"0.6610412\",\n \"0.65590703\",\n \"0.65477306\",\n \"0.6536954\",\n \"0.6498154\",\n \"0.64939207\",\n \"0.6468801\",\n \"0.64552736\",\n \"0.6453763\",\n \"0.6427407\",\n \"0.6414381\",\n \"0.6392772\",\n \"0.63516915\",\n \"0.63411623\",\n \"0.62807196\",\n \"0.62689686\",\n \"0.6214962\",\n \"0.62117195\",\n \"0.62079644\",\n \"0.61592484\",\n \"0.6149697\",\n \"0.61328137\",\n \"0.61269367\",\n \"0.61089015\",\n \"0.6094596\",\n \"0.6094278\",\n \"0.6093638\",\n \"0.608528\",\n \"0.607657\",\n \"0.6035048\",\n \"0.603339\",\n \"0.6028498\",\n \"0.6020109\",\n \"0.59824723\",\n \"0.5960622\",\n \"0.595433\",\n \"0.5934617\",\n \"0.59298956\",\n \"0.59262687\",\n \"0.59163946\",\n \"0.59048265\",\n \"0.5893434\",\n \"0.58823365\",\n \"0.58514017\",\n \"0.58348525\",\n \"0.58199173\",\n \"0.58145905\",\n \"0.57968074\",\n \"0.57941794\",\n \"0.5784296\",\n \"0.57827336\",\n \"0.5768678\",\n \"0.5765457\",\n \"0.5762953\",\n \"0.57607174\",\n \"0.5756519\",\n \"0.5747187\",\n \"0.5746166\",\n \"0.57438624\",\n \"0.5738178\",\n \"0.5735377\",\n \"0.5732583\",\n \"0.57299197\",\n \"0.57299197\",\n \"0.5728584\",\n \"0.57270306\",\n \"0.5726033\",\n \"0.5721253\",\n \"0.5717768\",\n \"0.5716813\",\n \"0.5712355\",\n \"0.5705056\",\n \"0.5694271\",\n \"0.5693785\",\n \"0.5687486\",\n \"0.56836724\",\n \"0.5681856\",\n \"0.56810653\",\n \"0.5678886\",\n \"0.5674441\",\n \"0.5673957\",\n \"0.56637174\",\n \"0.56634414\",\n \"0.5658577\",\n \"0.56571954\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7824741"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20165,"cells":{"query":{"kind":"string","value":"Get all values for the given annotation"},"document":{"kind":"string","value":"def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_annotations(self):\n entity = self.get_object()\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\n return Response(serializer.data)","def handle_enum(enum_annotations: Any) -> list:\n result = []\n for attribute in list(enum_annotations):\n result.append(attribute.value)\n return result","def values(self):\n return iter(util.annotate(v) for _, v in self._pairs())","def GetAnnotations(args, messages):\n annotations = getattr(args, 'annotations', {})\n additional_property_messages = []\n if not annotations:\n return None\n\n for key, value in annotations.items():\n additional_property_messages.append(\n messages.V2Key.AnnotationsValue.AdditionalProperty(\n key=key, value=value))\n\n annotation_value_message = messages.V2Key.AnnotationsValue(\n additionalProperties=additional_property_messages)\n\n return annotation_value_message","def _get_vals(self, doc: Doc) -> Iterable[V]:\n raise NotImplementedError","def annotation(self):\n return (self._name, self._value)","def values(self, *args, **kwargs):\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]","def values():","def GetValues(self):","def _annotations(request):\n result = Search(request).run(MultiDict(request.params))\n\n return request.find_service(AnnotationReadService).get_annotations_by_id(\n ids=result.annotation_ids\n )","def annotations(self):\n return self._annotations","def values(self):\n return [getattr(self, a.name) for a in self.__attrs_attrs__]","def GetValues(self):\n ...","def GetValues(self):\n ...","def get_values(self):\n \n return []","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\n return pulumi.get(self, \"annotations\")","def get_annotations(graph):\n return set(_annotation_iter_helper(graph))","def annotations(self):\n\n return self._annotations","def get_values(self):\n raise NotImplementedError(\"Abstract method not implemented.\")","def values(self):\n return self._tagged.values()","def values(self):\r\n return [self[k] for k in self]","def values(self):\n return self[\"values\"]","def values(self):\n return self[\"values\"]","def get_all_values(self):\n return self.display_table.get_all_values(root=self.display_table_root,include=self.params)","def values(self):\n return [ self[x] for x in self ]","def getValues(self):\n return self.__get('values')","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\n return pulumi.get(self, \"annotations\")","def valuerefs(self):\r\n return self.data.values()","def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))","def values(self):\n return [i.value for i in self.value]","def _parse_anno_info(self, annotations):\n gt_bboxes, gt_bboxes_ignore = [], []\n gt_masks, gt_masks_ignore = [], []\n gt_labels = []\n for ann in annotations:\n if ann.get('iscrowd', False):\n gt_bboxes_ignore.append(ann['bbox'])\n gt_masks_ignore.append(ann.get('segmentation', None))\n else:\n gt_bboxes.append(ann['bbox'])\n gt_labels.append(ann['category_id'])\n gt_masks.append(ann.get('segmentation', None))\n if gt_bboxes:\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\n gt_labels = np.array(gt_labels, dtype=np.int64)\n else:\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\n gt_labels = np.array([], dtype=np.int64)\n\n if gt_bboxes_ignore:\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\n else:\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\n\n ann = dict(\n bboxes=gt_bboxes,\n labels=gt_labels,\n bboxes_ignore=gt_bboxes_ignore,\n masks_ignore=gt_masks_ignore,\n masks=gt_masks)\n\n return ann","def GetAnnotationsQS(self):\n return self._costly_annotations_qs","def _annotation_iter_helper(graph):\n return (\n key\n for _, _, data in graph.edges(data=True)\n if ANNOTATIONS in data\n for key in data[ANNOTATIONS]\n )","def get_annotations(self, img_id):\n return self._img_id2annotations.get(img_id, [])","def all_values(cls) -> List[str]:\n return list(member.value for member in cls.__members__.values())","def all_annotation_fns(self):\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]","def values(self):\n return [p.value for p in self]","def values(self):\n return self.attrs.values()","def get_annotations_containing_keyword(graph, keyword):\n return [\n {\n 'annotation': annotation,\n 'value': value\n }\n for annotation, value in iter_annotation_value_pairs(graph)\n if keyword.lower() in value.lower()\n ]","def get_values(self):\n return map(lambda x: x.value(),self)","def get_values(self, names):\n r = []\n for n in names:\n if n in self.raw_metrics:\n r.append(self.raw_metrics[n])\n else:\n return None\n return r","def values(self) -> List:\n pass","def values(self, annotated=False, as_list=False, separator='\\t'):\n if not self.attrs():\n return None\n if annotated:\n list_repr = [\"{}:{}\".format(attr, val) for attr, val in\n zip(self.__slots__, self._values(to_str=True))]\n else:\n list_repr = self._values(to_str=True)\n if as_list:\n return list_repr\n else:\n return separator.join(list_repr)","def value(self):\n return [ f.value() for f in self.fields ]","def get_attr_values_with_name(self, name):\n return [attr.value for attr in self.get_attrs_with_name(name)]","def Values(self):\r\n\t\treturn self._get_attribute('values')","def palues(self):\n return self[self.peys()]","def palues(self):\n return self[self.peys()]","def values(self):\n return [self[name] for name in self.keys()]","def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\n annotations = []\n for item in self.collector:\n data_file_type = os.path.basename(item).split(\".\")[-1]\n annotations.append(\n load_annotation_file(\n os.path.join(\n self.annotation_folder,\n os.path.basename(item).replace(data_file_type, \"json\"),\n )\n )\n )\n\n return annotations","def values(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\n return pulumi.get(self, \"values\")","def get_all(self, cube_name: str, **kwargs) -> List[Annotation]:\n url = format_url(\"/api/v1/Cubes('{}')/Annotations?$expand=DimensionalContext($select=Name)\", cube_name)\n response = self._rest.GET(url, **kwargs)\n\n annotations_as_dict = response.json()['value']\n annotations = [Annotation.from_json(json.dumps(element)) for element in annotations_as_dict]\n return annotations","def get_sub_values(self):\n return list()","def get_values():\n a1 = insert_data(\"a1\")\n r = insert_data(\"r\")\n n = insert_data(\"n\")\n return a1, r, n","def values(self) -> list:\n return self.__values","def values(self):\n # Account for events generated with different versions of code.\n values = [getattr(self, x, \"\") for x in self.base_field_names()]\n values += [self.data.get(x, \"\") for x in self.data]\n return values","def get_tag_values(self, event):\n raise NotImplementedError","def values(self):\n return self.data['values'].values","def _all_raw_values(self, *fields):\n values = []\n for field in fields:\n if field in self._raw_fields_aggregate:\n values += self._raw_fields_aggregate[field]\n if values:\n return values","def annotations(self):\n\t\tif self._record is not None:\n\t\t return self._record.annotations\n\t\telse:\n\t\t return {}","def getValues(self):\n return [ float(val.text()) for val in self.values ]","def _get_values(self) -> ty.List[float]:\r\n ...","def values(self):\n return [self[k] for k in self.keys()]","def values(self):\n return self.docs.values()","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def values(self):\n return [self[key] for key in self.keys()]","def getValue(self):\n return self.field.getValues()","def values(self):\n return self.datasource.data[\"values\"]","def get_annotations(data_folder):\n annotations_files = os.listdir('data_annotations')\n\n annotations = {}\n for file_name in annotations_files:\n annotation = json.load(\n open(f'{data_folder}/annotations/{file_name}', 'r')\n )\n key = int(annotation['entity_id'])\n annotations[key] = annotation['value']['value']\n\n return annotations","def _values(self):\n return self.__values","def values(self):\n vals = []\n narrays = self.VTKObject.GetNumberOfArrays()\n for i in range(narrays):\n a = self.VTKObject.GetAbstractArray(i)\n if a.GetName():\n vals.append(a)\n return vals","def values(self):\r\n return self.__values","def get_marking_values():\n array = np.arange(0, MAX_MARK_VALUE +1).tolist()\n return array","def get_all_attribute(self):\n for attr, value in self.__dict__.items():\n print(attr, value)","def values(self):\n store = getMainStore()\n tagIDs = self._getTagIDs()\n where = self._getWhereClause(tagIDs)\n return store.find((Tag, TagValue), *where)","def values(self):\n\t\treturn self.myVals","def values(self):\n values = []\n for key in self.keys():\n values.append(self[key])\n return values","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def values(self) -> Sequence[str]:\n return pulumi.get(self, \"values\")","def _get_fields(annotations):\n annotation_fields = OrderedDict()\n for name, annotation in annotations.items():\n # Skip return type\n if name == \"return\":\n continue\n # Handle EnumMeta annotation\n if isinstance(annotation, EnumMeta):\n annotation = EnumInput(type=\"string\", enum=annotation)\n # Try create annotation by type when got like 'param: int'\n if not _is_dsl_type_cls(annotation) and not _is_dsl_types(annotation):\n annotation = _get_annotation_cls_by_type(annotation, raise_error=False)\n if not annotation:\n # Fall back to string parameter\n annotation = Input._get_default_string_input()\n annotation_fields[name] = annotation\n return annotation_fields","def get_all_param_values(layer):\n params = get_all_params(layer)\n return [p.get_value() for p in params]"],"string":"[\n \"def get_annotations(self):\\n entity = self.get_object()\\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\\n return Response(serializer.data)\",\n \"def handle_enum(enum_annotations: Any) -> list:\\n result = []\\n for attribute in list(enum_annotations):\\n result.append(attribute.value)\\n return result\",\n \"def values(self):\\n return iter(util.annotate(v) for _, v in self._pairs())\",\n \"def GetAnnotations(args, messages):\\n annotations = getattr(args, 'annotations', {})\\n additional_property_messages = []\\n if not annotations:\\n return None\\n\\n for key, value in annotations.items():\\n additional_property_messages.append(\\n messages.V2Key.AnnotationsValue.AdditionalProperty(\\n key=key, value=value))\\n\\n annotation_value_message = messages.V2Key.AnnotationsValue(\\n additionalProperties=additional_property_messages)\\n\\n return annotation_value_message\",\n \"def _get_vals(self, doc: Doc) -> Iterable[V]:\\n raise NotImplementedError\",\n \"def annotation(self):\\n return (self._name, self._value)\",\n \"def values(self, *args, **kwargs):\\n return [ self._get(doc, *args, **kwargs) for doc in self.keys(*args, **kwargs) ]\",\n \"def values():\",\n \"def GetValues(self):\",\n \"def _annotations(request):\\n result = Search(request).run(MultiDict(request.params))\\n\\n return request.find_service(AnnotationReadService).get_annotations_by_id(\\n ids=result.annotation_ids\\n )\",\n \"def annotations(self):\\n return self._annotations\",\n \"def values(self):\\n return [getattr(self, a.name) for a in self.__attrs_attrs__]\",\n \"def GetValues(self):\\n ...\",\n \"def GetValues(self):\\n ...\",\n \"def get_values(self):\\n \\n return []\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Mapping[str, str]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> pulumi.Output[Mapping[str, Any]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def get_annotations(graph):\\n return set(_annotation_iter_helper(graph))\",\n \"def annotations(self):\\n\\n return self._annotations\",\n \"def get_values(self):\\n raise NotImplementedError(\\\"Abstract method not implemented.\\\")\",\n \"def values(self):\\n return self._tagged.values()\",\n \"def values(self):\\r\\n return [self[k] for k in self]\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def values(self):\\n return self[\\\"values\\\"]\",\n \"def get_all_values(self):\\n return self.display_table.get_all_values(root=self.display_table_root,include=self.params)\",\n \"def values(self):\\n return [ self[x] for x in self ]\",\n \"def getValues(self):\\n return self.__get('values')\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def annotations(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"annotations\\\")\",\n \"def valuerefs(self):\\r\\n return self.data.values()\",\n \"def count_annotation_values(graph, annotation):\\n return Counter(iter_annotation_values(graph, annotation))\",\n \"def values(self):\\n return [i.value for i in self.value]\",\n \"def _parse_anno_info(self, annotations):\\n gt_bboxes, gt_bboxes_ignore = [], []\\n gt_masks, gt_masks_ignore = [], []\\n gt_labels = []\\n for ann in annotations:\\n if ann.get('iscrowd', False):\\n gt_bboxes_ignore.append(ann['bbox'])\\n gt_masks_ignore.append(ann.get('segmentation', None))\\n else:\\n gt_bboxes.append(ann['bbox'])\\n gt_labels.append(ann['category_id'])\\n gt_masks.append(ann.get('segmentation', None))\\n if gt_bboxes:\\n gt_bboxes = np.array(gt_bboxes, dtype=np.float32)\\n gt_labels = np.array(gt_labels, dtype=np.int64)\\n else:\\n gt_bboxes = np.zeros((0, 4), dtype=np.float32)\\n gt_labels = np.array([], dtype=np.int64)\\n\\n if gt_bboxes_ignore:\\n gt_bboxes_ignore = np.array(gt_bboxes_ignore, dtype=np.float32)\\n else:\\n gt_bboxes_ignore = np.zeros((0, 4), dtype=np.float32)\\n\\n ann = dict(\\n bboxes=gt_bboxes,\\n labels=gt_labels,\\n bboxes_ignore=gt_bboxes_ignore,\\n masks_ignore=gt_masks_ignore,\\n masks=gt_masks)\\n\\n return ann\",\n \"def GetAnnotationsQS(self):\\n return self._costly_annotations_qs\",\n \"def _annotation_iter_helper(graph):\\n return (\\n key\\n for _, _, data in graph.edges(data=True)\\n if ANNOTATIONS in data\\n for key in data[ANNOTATIONS]\\n )\",\n \"def get_annotations(self, img_id):\\n return self._img_id2annotations.get(img_id, [])\",\n \"def all_values(cls) -> List[str]:\\n return list(member.value for member in cls.__members__.values())\",\n \"def all_annotation_fns(self):\\n return [a[1] for a in getmembers(self, lambda x: isinstance(x, RowAnnotation))]\",\n \"def values(self):\\n return [p.value for p in self]\",\n \"def values(self):\\n return self.attrs.values()\",\n \"def get_annotations_containing_keyword(graph, keyword):\\n return [\\n {\\n 'annotation': annotation,\\n 'value': value\\n }\\n for annotation, value in iter_annotation_value_pairs(graph)\\n if keyword.lower() in value.lower()\\n ]\",\n \"def get_values(self):\\n return map(lambda x: x.value(),self)\",\n \"def get_values(self, names):\\n r = []\\n for n in names:\\n if n in self.raw_metrics:\\n r.append(self.raw_metrics[n])\\n else:\\n return None\\n return r\",\n \"def values(self) -> List:\\n pass\",\n \"def values(self, annotated=False, as_list=False, separator='\\\\t'):\\n if not self.attrs():\\n return None\\n if annotated:\\n list_repr = [\\\"{}:{}\\\".format(attr, val) for attr, val in\\n zip(self.__slots__, self._values(to_str=True))]\\n else:\\n list_repr = self._values(to_str=True)\\n if as_list:\\n return list_repr\\n else:\\n return separator.join(list_repr)\",\n \"def value(self):\\n return [ f.value() for f in self.fields ]\",\n \"def get_attr_values_with_name(self, name):\\n return [attr.value for attr in self.get_attrs_with_name(name)]\",\n \"def Values(self):\\r\\n\\t\\treturn self._get_attribute('values')\",\n \"def palues(self):\\n return self[self.peys()]\",\n \"def palues(self):\\n return self[self.peys()]\",\n \"def values(self):\\n return [self[name] for name in self.keys()]\",\n \"def _get_annotations(self) -> List[Dict[int, Dict[str, Any]]]:\\n annotations = []\\n for item in self.collector:\\n data_file_type = os.path.basename(item).split(\\\".\\\")[-1]\\n annotations.append(\\n load_annotation_file(\\n os.path.join(\\n self.annotation_folder,\\n os.path.basename(item).replace(data_file_type, \\\"json\\\"),\\n )\\n )\\n )\\n\\n return annotations\",\n \"def values(self) -> pulumi.Output[Optional[Mapping[str, Any]]]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def get_all(self, cube_name: str, **kwargs) -> List[Annotation]:\\n url = format_url(\\\"/api/v1/Cubes('{}')/Annotations?$expand=DimensionalContext($select=Name)\\\", cube_name)\\n response = self._rest.GET(url, **kwargs)\\n\\n annotations_as_dict = response.json()['value']\\n annotations = [Annotation.from_json(json.dumps(element)) for element in annotations_as_dict]\\n return annotations\",\n \"def get_sub_values(self):\\n return list()\",\n \"def get_values():\\n a1 = insert_data(\\\"a1\\\")\\n r = insert_data(\\\"r\\\")\\n n = insert_data(\\\"n\\\")\\n return a1, r, n\",\n \"def values(self) -> list:\\n return self.__values\",\n \"def values(self):\\n # Account for events generated with different versions of code.\\n values = [getattr(self, x, \\\"\\\") for x in self.base_field_names()]\\n values += [self.data.get(x, \\\"\\\") for x in self.data]\\n return values\",\n \"def get_tag_values(self, event):\\n raise NotImplementedError\",\n \"def values(self):\\n return self.data['values'].values\",\n \"def _all_raw_values(self, *fields):\\n values = []\\n for field in fields:\\n if field in self._raw_fields_aggregate:\\n values += self._raw_fields_aggregate[field]\\n if values:\\n return values\",\n \"def annotations(self):\\n\\t\\tif self._record is not None:\\n\\t\\t return self._record.annotations\\n\\t\\telse:\\n\\t\\t return {}\",\n \"def getValues(self):\\n return [ float(val.text()) for val in self.values ]\",\n \"def _get_values(self) -> ty.List[float]:\\r\\n ...\",\n \"def values(self):\\n return [self[k] for k in self.keys()]\",\n \"def values(self):\\n return self.docs.values()\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def values(self):\\n return [self[key] for key in self.keys()]\",\n \"def getValue(self):\\n return self.field.getValues()\",\n \"def values(self):\\n return self.datasource.data[\\\"values\\\"]\",\n \"def get_annotations(data_folder):\\n annotations_files = os.listdir('data_annotations')\\n\\n annotations = {}\\n for file_name in annotations_files:\\n annotation = json.load(\\n open(f'{data_folder}/annotations/{file_name}', 'r')\\n )\\n key = int(annotation['entity_id'])\\n annotations[key] = annotation['value']['value']\\n\\n return annotations\",\n \"def _values(self):\\n return self.__values\",\n \"def values(self):\\n vals = []\\n narrays = self.VTKObject.GetNumberOfArrays()\\n for i in range(narrays):\\n a = self.VTKObject.GetAbstractArray(i)\\n if a.GetName():\\n vals.append(a)\\n return vals\",\n \"def values(self):\\r\\n return self.__values\",\n \"def get_marking_values():\\n array = np.arange(0, MAX_MARK_VALUE +1).tolist()\\n return array\",\n \"def get_all_attribute(self):\\n for attr, value in self.__dict__.items():\\n print(attr, value)\",\n \"def values(self):\\n store = getMainStore()\\n tagIDs = self._getTagIDs()\\n where = self._getWhereClause(tagIDs)\\n return store.find((Tag, TagValue), *where)\",\n \"def values(self):\\n\\t\\treturn self.myVals\",\n \"def values(self):\\n values = []\\n for key in self.keys():\\n values.append(self[key])\\n return values\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def values(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"values\\\")\",\n \"def _get_fields(annotations):\\n annotation_fields = OrderedDict()\\n for name, annotation in annotations.items():\\n # Skip return type\\n if name == \\\"return\\\":\\n continue\\n # Handle EnumMeta annotation\\n if isinstance(annotation, EnumMeta):\\n annotation = EnumInput(type=\\\"string\\\", enum=annotation)\\n # Try create annotation by type when got like 'param: int'\\n if not _is_dsl_type_cls(annotation) and not _is_dsl_types(annotation):\\n annotation = _get_annotation_cls_by_type(annotation, raise_error=False)\\n if not annotation:\\n # Fall back to string parameter\\n annotation = Input._get_default_string_input()\\n annotation_fields[name] = annotation\\n return annotation_fields\",\n \"def get_all_param_values(layer):\\n params = get_all_params(layer)\\n return [p.get_value() for p in params]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.67769945","0.6325543","0.6274638","0.6220138","0.6180968","0.6171129","0.61034197","0.60787046","0.60713106","0.6068879","0.5992964","0.59564936","0.59216946","0.59216946","0.59015006","0.5887698","0.5887698","0.5886613","0.5818207","0.5798842","0.5798271","0.5781662","0.57796156","0.5766157","0.5766157","0.5762097","0.57582843","0.57390237","0.56659573","0.56659573","0.564126","0.56248385","0.5622265","0.5609565","0.5589622","0.5584108","0.5573938","0.55708194","0.5569764","0.55656403","0.5534901","0.5531716","0.5529284","0.552913","0.5514246","0.55086935","0.55022573","0.5498711","0.5476181","0.5473757","0.5473757","0.5471878","0.54552054","0.5449099","0.5429702","0.541955","0.54164684","0.54104966","0.5408072","0.5400444","0.54001606","0.53846234","0.5382371","0.53666383","0.53618586","0.5357885","0.5353992","0.5349604","0.5349604","0.5349604","0.53476137","0.5346242","0.5342693","0.53395784","0.53369844","0.53315735","0.5325532","0.53194344","0.5315901","0.5313754","0.5311482","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.5303448","0.53000206","0.5271627"],"string":"[\n \"0.67769945\",\n \"0.6325543\",\n \"0.6274638\",\n \"0.6220138\",\n \"0.6180968\",\n \"0.6171129\",\n \"0.61034197\",\n \"0.60787046\",\n \"0.60713106\",\n \"0.6068879\",\n \"0.5992964\",\n \"0.59564936\",\n \"0.59216946\",\n \"0.59216946\",\n \"0.59015006\",\n \"0.5887698\",\n \"0.5887698\",\n \"0.5886613\",\n \"0.5818207\",\n \"0.5798842\",\n \"0.5798271\",\n \"0.5781662\",\n \"0.57796156\",\n \"0.5766157\",\n \"0.5766157\",\n \"0.5762097\",\n \"0.57582843\",\n \"0.57390237\",\n \"0.56659573\",\n \"0.56659573\",\n \"0.564126\",\n \"0.56248385\",\n \"0.5622265\",\n \"0.5609565\",\n \"0.5589622\",\n \"0.5584108\",\n \"0.5573938\",\n \"0.55708194\",\n \"0.5569764\",\n \"0.55656403\",\n \"0.5534901\",\n \"0.5531716\",\n \"0.5529284\",\n \"0.552913\",\n \"0.5514246\",\n \"0.55086935\",\n \"0.55022573\",\n \"0.5498711\",\n \"0.5476181\",\n \"0.5473757\",\n \"0.5473757\",\n \"0.5471878\",\n \"0.54552054\",\n \"0.5449099\",\n \"0.5429702\",\n \"0.541955\",\n \"0.54164684\",\n \"0.54104966\",\n \"0.5408072\",\n \"0.5400444\",\n \"0.54001606\",\n \"0.53846234\",\n \"0.5382371\",\n \"0.53666383\",\n \"0.53618586\",\n \"0.5357885\",\n \"0.5353992\",\n \"0.5349604\",\n \"0.5349604\",\n \"0.5349604\",\n \"0.53476137\",\n \"0.5346242\",\n \"0.5342693\",\n \"0.53395784\",\n \"0.53369844\",\n \"0.53315735\",\n \"0.5325532\",\n \"0.53194344\",\n \"0.5315901\",\n \"0.5313754\",\n \"0.5311482\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.5303448\",\n \"0.53000206\",\n \"0.5271627\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.75477934"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20166,"cells":{"query":{"kind":"string","value":"Counts in how many edges each annotation appears in a graph, but filter out source nodes and target nodes"},"document":{"kind":"string","value":"def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):\n source_filter = keep_node_permissive if source_filter is None else source_filter\n target_filter = keep_node_permissive if target_filter is None else target_filter\n\n return Counter(\n data[ANNOTATIONS][annotation]\n for u, v, data in graph.edges_iter(data=True)\n if edge_has_annotation(data, annotation) and source_filter(graph, u) and target_filter(graph, v)\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2","def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))","def __filterEdges(self):","def count_nodes(self, term=None, labels: istr = None):","def get_indegrees(graph: Graph):\n transpose = get_transpose_graph(graph)\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}","def count_nodes(self, term=None, labels: istr = None) -> int:","def proximal_neighbor_count(source : Image, destination : Image = None, min_distance : float = 0, max_distance : float = np.finfo(np.float32).max) -> Image:\n from .._tier1 import set_column\n from .._tier9 import centroids_of_labels\n from .._tier1 import generate_distance_matrix\n from .._tier3 import generate_proximal_neighbors_matrix\n from .._tier1 import count_touching_neighbors\n\n pointlist = centroids_of_labels(source)\n distance_matrix = generate_distance_matrix(pointlist, pointlist)\n\n touch_matrix = generate_proximal_neighbors_matrix(distance_matrix, min_distance=min_distance, max_distance=max_distance)\n destination = count_touching_neighbors(touch_matrix, destination)\n set_column(destination, 0, 0)\n return destination","def init_inbound_counts(nodes, edges):\n inbound_counts = {}\n for node in nodes:\n inbound_counts[node] = 0\n for e in edges:\n inbound_counts[e[1]] = inbound_counts[e[1]] + 1\n return inbound_counts","def num_ad_pruning(edge_list=\n path+'connected-component-analysis-round2/network-profiling-data/cid6_analysis/cid6-edge-list',\n worker_ads_file = path+'connected-component-analysis-round2/network-profiling-data/cid6_analysis/worker-ads-int-dict.json'):\n G = nx.read_edgelist(edge_list, delimiter='\\t')\n worker_ints = json.load(open(worker_ads_file, 'r'))\n print nx.info(G)\n threshold = 16\n count = 0\n forbidden_phones = set()\n # with codecs.open(edge_phone_count, 'r', 'utf-8') as f:\n # for line in f:\n # obj = json.loads(line[0:-1])\n # if int(obj.keys()[0]) >= threshold:\n # forbidden_phones = forbidden_phones.union(set(obj[obj.keys()[0]]))\n # with codecs.open(phone_edge_list, 'r', 'utf-8') as f:\n # for line in f:\n # fields = re.split('\\t', line[0:-1])\n # phones = set(fields[2:])\n # if len(phones.intersection(forbidden_phones)) != 0:\n # count += 1\n # G.remove_edge(fields[0], fields[1])\n H = nx.Graph()\n for e in G.edges:\n if e[0] not in worker_ints or e[1] not in worker_ints:\n raise Exception\n else:\n if len(worker_ints[e[0]]) < threshold and len(worker_ints[e[1]]) < threshold:\n H.add_edge(e[0], e[1])\n else:\n count += 1\n print str(count),' edges pruned from graph'\n print nx.info(H)\n ccs = sorted(nx.connected_components(H), key=len, reverse=True)\n print len(ccs)\n print len(ccs[0])","def edgecount(self):\n\n raise NotImplementedError","def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )","def sum_edges(g, source, hops):\n\n edges = 0\n\n paths = nx.single_source_shortest_path(g, source, hops)\n for node in paths.iterkeys():\n edges += len(g.neighbors(node))\n\n return edges","def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2","def reduce_inbound_connections(inbound_counts, nodes):\n nodes_without_inbound = []\n for node in nodes:\n inbound_counts[node] = inbound_counts[node] - 1\n if inbound_counts[node] == 0:\n nodes_without_inbound.append(node)\n return nodes_without_inbound","def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))","def street_segment_count(Gu):\n if nx.is_directed(Gu): # pragma: no cover\n msg = \"`Gu` must be undirected\"\n raise ValueError(msg)\n return len(Gu.edges)","def local_node_connectivity(G, source, target, cutoff=None):\n if target == source:\n raise nx.NetworkXError(\"source and target have to be different nodes.\")\n\n # Maximum possible node independent paths\n if G.is_directed():\n possible = min(G.out_degree(source), G.in_degree(target))\n else:\n possible = min(G.degree(source), G.degree(target))\n\n K = 0\n if not possible:\n return K\n\n if cutoff is None:\n cutoff = INF\n\n exclude = set()\n for i in range(min(possible, cutoff)):\n try:\n path = _bidirectional_shortest_path(G, source, target, exclude)\n exclude.update(set(path))\n K += 1\n except nx.NetworkXNoPath:\n break\n\n return K","def nodes_per_time_step(graphs: typ.Iterable[vtna.graph.Graph]) -> typ.List[int]:\n return [len(set(node for edge in graph.get_edges() for node in edge.get_incident_nodes())) for graph in graphs]","def return_num_edges(self):\n return sum(map(lambda x: len(x),self.__adj))","def _prune_graph(self, graph, target_graph):\n count = 1\n _logger.debug(\n '|----+----------------------------------------+------------------------------+------------------------------|'\n )\n _logger.debug('|{:^4}|{:^40}|{:^30}|{:^30}|'.format('id', 'parammeter',\n 'from', 'to'))\n for param in target_graph.all_parameters():\n var = graph.var(param.name())\n ori_shape = var.shape()\n var.set_shape(param.shape())\n _logger.debug(\n '|----+----------------------------------------+------------------------------+------------------------------|'\n )\n _logger.debug('|{:^4}|{:^40}|{:^30}|{:^30}|'.format(\n str(count),\n str(param.name()), str(ori_shape), str(param.shape())))\n count += 1\n _logger.debug(\n '|----+----------------------------------------+------------------------------+------------------------------|'\n )","def control_edge_count(self) -> int:\n return int(self.graph_tuple_stats.control_edge_count or 0)","def test_count_neighbors(self):\n m, n = 5, 5\n k, p = 0.2, 0.7\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\n C = ConwayModel(m, n, k, p, agents)\n\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\n result = C.count_neighbors(to_count)\n self.assertTrue(np.all(expected == result))","def count_fillin(graph, nodes):\n count = 0\n for v1 in nodes:\n for v2 in nodes:\n if v1 != v2 and v2 not in graph[v1]:\n count += 1\n return count / 2","def intersection_count(G=None, min_streets=2):\n spn = streets_per_node(G)\n node_ids = set(G.nodes)\n return sum(count >= min_streets and node in node_ids for node, count in spn.items())","def _num_edges(self):\n return len(self._eid2partid)","def get_nb_edit_operations(g1, g2, forward_map, backward_map):\n n_vi = 0\n n_vr = 0\n n_vs = 0\n n_ei = 0\n n_er = 0\n n_es = 0\n\n nodes1 = [n for n in g1.nodes()]\n for i, map_i in enumerate(forward_map):\n if map_i == np.inf:\n n_vr += 1\n elif g1.nodes[nodes1[i]]['atom_symbol'] != g2.nodes[map_i]['atom_symbol']:\n n_vs += 1\n for map_i in backward_map:\n if map_i == np.inf:\n n_vi += 1\n\n# idx_nodes1 = range(0, len(node1))\n\n edges1 = [e for e in g1.edges()]\n nb_edges2_cnted = 0\n for n1, n2 in edges1:\n idx1 = nodes1.index(n1)\n idx2 = nodes1.index(n2)\n # one of the nodes is removed, thus the edge is removed.\n if forward_map[idx1] == np.inf or forward_map[idx2] == np.inf:\n n_er += 1\n # corresponding edge is in g2. Edge label is not considered.\n elif (forward_map[idx1], forward_map[idx2]) in g2.edges() or \\\n (forward_map[idx2], forward_map[idx1]) in g2.edges():\n nb_edges2_cnted += 1\n # corresponding nodes are in g2, however the edge is removed.\n else:\n n_er += 1\n n_ei = nx.number_of_edges(g2) - nb_edges2_cnted\n\n return n_vi, n_vr, n_vs, n_ei, n_er, n_es","def _scan_targets(self, indices_to_nodes, node_property, source_index,\n factor_aggregator, compute_statistics,\n total_factor_instances,\n generated_edges, reverse_edges=False, limit=None,\n verbose=False):\n edge_list = []\n for target_index in range(source_index + 1, len(indices_to_nodes)):\n s = indices_to_nodes[source_index]\n t = indices_to_nodes[target_index]\n\n if node_property is not None:\n s_factors, t_factors = self._get_node_factors(\n s, t, node_property, factor_aggregator)\n else:\n if factor_aggregator is None:\n factor_aggregator = aggregate_index\n s_factors, t_factors = self._get_edge_factors(\n s, t, factor_aggregator, reverse_edges)\n\n common_factors = safe_intersection(\n s_factors, t_factors)\n\n if len(common_factors) > 0:\n edge = {\n \"@source_id\": s,\n \"@target_id\": t,\n \"common_factors\": common_factors\n }\n\n for stat in compute_statistics:\n edge[stat] = COOCCURRENCE_STATISTICS[stat](\n self.pgframe, s, t,\n node_property,\n common_factors,\n total_factor_instances,\n factor_aggregator,\n reverse_edges)\n\n edge_list.append(edge)\n\n if limit:\n if len(generated_edges) + len(edge_list) == limit:\n if verbose:\n print(\"Reached the edge limit ({})\".format(limit))\n return edge_list\n\n return edge_list","def node_count(self) -> int:\n return int(self.graph_tuple_stats.node_count or 0)","def num_edges(self):\n return sum(1 for _ in self.iteredges())","def count_unvisited(data):\n count = sum(n.count(\"n\") for n in data)\n return count","def edge_count(self) -> int:\n return int(self.graph_tuple_stats.edge_count or 0)","def numShortestPaths(g, start, end):\n if g == None or start == None or end == None:\n raise InvalidInputException(\"Input is null.\")\n if not g.containsVertex(start) or not g.containsVertex(end):\n raise InvalidInputException(\"Doesn't contain source.\")\n nodes = []\n nodes.append(start)\n # Adds two decorations to the vertices\n for node in g.iterVertices():\n node.minCount = float(\"inf\")\n node.numCount = 0\n start.minCount = 0\n while not len(nodes) == 0:\n node = nodes.pop(0)\n # Base case: if node is the end node, return the numCount decoration\n if node == end:\n return node.numCount\n # Decorates neighboring nodes and adds them to the list\n for edge in g.incidentEdges(node):\n new_node = g.opposite(node,edge)\n if new_node.minCount == float(\"inf\"):\n new_node.minCount = node.minCount+1\n nodes.append(new_node)\n if new_node.minCount == node.minCount + 1:\n new_node.numCount = node.numCount + 1","def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)","def find_nodes(shp):\n node_count = {}\n for road in shp:\n vrts = road.vertices\n for node in vrts:\n if node not in node_count:\n node_count[node] = 0\n node_count[node] += 1\n node_count[vrts[0]] += 1\n node_count[vrts[-1]] += 1\n return set([node for node,c in node_count.iteritems() if c > 1])","def count_nodes(self):\n\t\treturn self.__count_nodes(self)","def add_neighbor_count_features(edge_df, X_df, structures_df):\n cnt_df = edge_df.groupby(\n ['molecule_name', 'atom_index_0']).size().to_frame('EF_neighbor_count')\n cnt_df.reset_index(inplace=True)\n cnt_df.rename({'atom_index_0': 'atom_index_zero'}, inplace=True, axis=1)\n\n X_df = X_df.reset_index()\n X_df = pd.merge(\n X_df,\n cnt_df,\n how='left',\n left_on=['molecule_name', 'atom_index_1'],\n right_on=['molecule_name', 'atom_index_zero'])\n\n X_df.rename({\n 'EF_neighbor_count': 'EF_atom_index_1_neighbor_count'\n },\n inplace=True,\n axis=1)\n X_df.drop(['atom_index_zero'], inplace=True, axis=1)\n X_df.set_index('id', inplace=True)\n incorrect_absence = 100 * X_df['EF_atom_index_1_neighbor_count'].isna(\n ).sum() / X_df.shape[0]\n print('[EdgeFeatures] Setting following percentage of edges to 0:',\n incorrect_absence)\n\n X_df['EF_atom_index_1_neighbor_count'] = X_df[\n 'EF_atom_index_1_neighbor_count'].fillna(0).astype(np.uint8)\n return X_df","def _count_discordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\n return torch.cat([_discordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)","def num_edges_rows(graph):\n return len(graph.graph.edges), len(graph.graph.nodes)","def node_graph(imageSkeleton, imageGaussian):\n ones = np.ones((3, 3))\n imageFiltered = sp.ndimage.generic_filter(imageSkeleton, node_find, footprint=ones, mode='constant', cval=0)\n imageNodeCondense = node_condense(imageFiltered, imageGaussian, ones)\n imageLabeledNodes = skimage.segmentation.relabel_sequential(imageNodeCondense)[0]\n imageLabeledSkeleton, labels = sp.ndimage.label(imageSkeleton, structure=ones)\n for label in range(1, labels + 1):\n detectedNodes = np.max((imageLabeledSkeleton == label) * (imageLabeledNodes > 0))\n if (detectedNodes == 0):\n imageSkeleton[imageLabeledSkeleton == label] = 0\n imageAnnotated = 1 * ((imageSkeleton + imageLabeledNodes) > 0) + imageLabeledNodes\n return(imageAnnotated)","def guess_num_nodes_from(edgelist):\n return np.max(edgelist) + 1","def _number_of_edges(self):\n if self._edges is None:\n return 0\n return len(self._edges)","def num_of_edge(self):\n try:\n return self.edges\n except:\n print(\"ERROR: No graph exists\")","def count(self):\n\t\treturn len(list(self.nodes))","def num_cusps_of_regions(self):\n G = self._get_puncturefinder_graph()\n # return [sum(G.subgraph(vertices=region).edge_labels())\n # for region in G.connected_components()]\n return [sum(edge[2]['weight']\n for edge in subgraph.edges(data=True))\n for subgraph in nx.connected_component_subgraphs(G)]","def getNumMarkedTargets(self):\n return len(self.getConTextModeNodes(\"target\"))","def getNumMarkedTargets(self):\n return len(self.getConTextModeNodes(\"target\"))","def make_graph(imageAnnotated, imageGaussian):\n nodeNumber = imageAnnotated.max() - 1\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\n imagePropagatedNodes = imageAnnotated.copy()\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\n dimensionY, dimensionX = imageAnnotated.shape\n filament = (imagePropagatedNodes == 1).sum()\n while (filament > 0):\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\n for posY, posX in nodePixel:\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\n filament = (imagePropagatedNodes == 1).sum()\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\n for posY, posX in zip(filamentY, filamentX):\n nodeIndex = imagePropagatedNodes[posY, posX]\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\n for index, pixel in enumerate(filamentNeighborhood):\n if (pixel != nodeIndex and pixel > 1):\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\n edgeConnectivity = 0\n edgeJump = 0\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\n return(graph, nodePositions)","def essential_node_count(self) -> int:\n return sum(\n 1 for n in self.graph.nodes() if n.kind() not in self._EXCLUDED_NODE_KINDS\n )","def streets_per_node(G):\n spn = dict(nx.get_node_attributes(G, \"street_count\"))\n if set(spn) != set(G.nodes):\n utils.log(\"Graph nodes changed since `street_count`s were calculated\", level=lg.WARN)\n return spn","def edge_sig(T, source=[], target=[], type_='out'):\n case_cnt = sum([v[0] for v in T['start'].values()])\n S = dict()\n for a_i in source:\n S[a_i] = dict()\n target_ = T if type_ != 'out' else T[a_i]\n for a_j in target_:\n if (a_i == a_j) | (a_j not in target): continue\n if type_ != 'out':\n if a_i in T[a_j]: S[a_i][a_j] = T[a_j][a_i][1] / case_cnt\n else: S[a_i][a_j] = T[a_i][a_j][1] / case_cnt\n return S","def Features(src, dest): \n # find common nodes of x and y\n common_out_x = out_edges.get(src,set())\n common_out_y = out_edges.get(dest, set())\n common_in_x = in_edges.get(src, set())\n common_in_y = in_edges.get(dest, set())\n\n\n intersection = (common_in_x|common_out_x) & \\\n (common_in_y|common_out_y)\n union = (common_in_x|common_out_x) | \\\n (common_in_y|common_out_y)\n\n # cosine similarity\n connected_x = common_out_x | common_in_x\n connected_y = common_out_y | common_in_y\n prod_xy = float(len(connected_x)*len(connected_y))\n cosine = len(intersection) / prod_xy if prod_xy != 0.0 else 0\n\n # jaccard\n jaccard = float(len(intersection)) / len(union) \\\n if len(union) > 0 else 0\n\n jaccard_mutate = Jaccard(dest, out_edges.get(src))\n\n #\n # compute the adamic/adar value of source node and\n # destination node\n adar_set = 0\n for z in intersection:\n degrees = 0\n # degrees of a common node\n if out_edges.get(z):\n degrees += len(out_edges[z]) \n if in_edges.get(z):\n degrees += len(in_edges[z]) \n\n if degrees != 0:\n adar_set += 1 / log(degrees)\n\n # preferential attachment\n pref_attach = len(connected_x) * len(connected_y)\n\n # kn1\n w_src_out = 1 / sqrt(1+len(common_out_x))\n w_dest_in = 1 / sqrt(1+len(common_in_y))\n w_kn1 = w_src_out * w_dest_in\n\n\n #return [len(common_out_x), len(common_in_y), jaccard, adar_set]\n return [src,\n dest,\n len(common_out_x),\n len(common_in_x),\n len(common_out_y),\n len(common_in_y), \n len(intersection),\n cosine,\n jaccard,\n jaccard_mutate,\n adar_set,\n pref_attach,\n w_kn1]","def clean_edges(self):","def number_active_neighbors(graph, node):\n return np.sum(\n [\n graph.nodes[neighbor_idx][\"agent\"].active\n for neighbor_idx in graph[node].keys()\n ]\n )","def __init__(self, graph, source=1, target=33):\n super().__init__(\"Path length\")\n self.source = source\n self.target = target\n self.graph = graph.copy()\n self.ind_dict = {}\n for i, (u, v) in enumerate(self.graph.edges):\n self.ind_dict[i] = (u, v)","def _count_bipartite_edges(G, X, Y):\n cpt = 0\n for edge in G.edges:\n v1 = edge.v1\n v2 = edge.v2\n if (X.__contains__(v1) and Y.__contains__(v2)) or (X.__contains__(v2) and Y.__contains__(v1)):\n cpt += 1\n return cpt","def hypergraph_common_edges(u, v, hypergraph):\n total = 0\n for e in hypergraph.edges():\n if u in e.elements and v in e.elements:\n total += 1\n return total","def count_streets_per_node(G, nodes=None):\n if nodes is None:\n nodes = G.nodes\n\n # get one copy of each self-loop edge, because bi-directional self-loops\n # appear twice in the undirected graph (u,v,0 and u,v,1 where u=v), but\n # one-way self-loops will appear only once\n Gu = G.to_undirected(reciprocal=False, as_view=True)\n self_loop_edges = set(nx.selfloop_edges(Gu))\n\n # get all non-self-loop undirected edges, including parallel edges\n non_self_loop_edges = [e for e in Gu.edges(keys=False) if e not in self_loop_edges]\n\n # make list of all unique edges including each parallel edge unless the\n # parallel edge is a self-loop, in which case we don't double-count it\n all_unique_edges = non_self_loop_edges + list(self_loop_edges)\n\n # flatten list of (u, v) edge tuples to count how often each node appears\n edges_flat = itertools.chain.from_iterable(all_unique_edges)\n counts = Counter(edges_flat)\n streets_per_node = {node: counts[node] for node in nodes}\n\n utils.log(\"Counted undirected street segments incident on each node\")\n return streets_per_node","def read_graph(args):\n dataset = pd.read_csv(args.features_path).values.tolist()\n edges = {}\n edges[\"positive_edges\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\n edges[\"negative_edges\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\n edges[\"ecount\"] = len(dataset)\n edges[\"ncount\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\n return edges","def num_edges(self):\r\n return len(self.__generate_edges())","def get_node_count(self) -> Iterable:\n return len([i for i in self.all_nodes_as_iterable()])","def countEdges(self):\n return numpy.count_nonzero(self.supportArray) / 2","def edge_mapping(self):\n ...","def prepare_graph(label, nodes, edges, graphID):\n features = {'label': label}\n\n G = nx.DiGraph()\n nodes[\"id\"] = nodes[\"id\"].apply(lambda x : str(x))\n features['num_nodes'] = nodes.shape[0]\n op_node = None\n times = []\n friends = []\n followers = []\n for index, row in nodes.iterrows():\n G.add_node(row['id'], time=row['time'], friends=row['friends'], followers = row['followers'])\n times.append(row['time'])\n friends.append(2**row['friends'])\n followers.append(2**row['followers'])\n if row['time'] == 0:\n features['poster_friend_cnt'] = 2**row['friends']\n features['poster_follower_cnt'] = 2**row['followers']\n tweeter_id = row['id']\n op_node = row['id']\n features['avg_time'] = np.mean(times)\n features['avg_friends'] = np.mean(friends)\n features['avg_followers'] = np.mean(followers)\n features['max_followers'] = max(followers)\n features['max_friends'] = max(friends)\n features['friends_25th_percentile'] = np.percentile(friends, 25)\n features['friends_75th_percentile'] = np.percentile(friends, 75)\n features['followers_25th_percentile'] = np.percentile(followers, 25)\n features['followers_75th_percentile'] = np.percentile(followers, 75)\n node_list = []\n edge_count = 0\n for pair in edges:\n node1, node2 = pair.split()[0], pair.split()[1]\n node_list.append(node1)\n node_list.append(node2)\n G.add_edge(node1, node2)\n edge_count += 1\n features['num_edges'] = edge_count\n sum_users_without_followers = sum([1 for (node, val) in G.in_degree() if val==0])\n features['ratio_users_w/out_followers'] = sum_users_without_followers / len(G.nodes)\n features['num_connected_components'] = nx.number_strongly_connected_components(G)\n features['number_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id)\n features['percentage_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id) / features['poster_follower_cnt']\n features['avg_clustering'] = nx.average_clustering(G)\n features['op_clustering'] = nx.clustering(G,op_node)\n features['transitivity'] = nx.transitivity(G)\n node_list = list(set(node_list))\n features['nodeID_list'] = np.array(node_list)\n features['graph_id'] = graphID\n return features, G","def edge_count(adjList):\n edges = {}\n for id, neigh in enumerate(adjList):\n for n in neigh:\n edges[max(n, id), min(n, id)] = id\n\n return len(edges)","def test_node_sampling(weighted_graph_config_fixture):\n w_config = weighted_graph_config_fixture\n\n # Node 5 to node 4 has zero weight (zero transition probability)\n # Node 4 to node 5 has ten weight (high transition probability)\n edges = pd.DataFrame({'source_content_id': [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5],\n 'destination_content_id': [5, 1, 0, 3, 4, 1, 2, 1, 3, 5, 3, 4],\n 'weight': [1, 2, 3, 4, 1, 2, 3, 4, 1, 10, 5, 0]}\n )\n wm = N2VModel()\n\n wm.create_graph(edges, w_config['weighted_graph'])\n\n wm.generate_walks(**w_config)\n\n wm.fit_model(**w_config, callbacks=EpochLogger())\n\n n_nodes = len(set(edges.source_content_id))\n n_transitions = n_nodes * (w_config['walk_length'] - 1) * w_config['num_walks']\n\n res = np.array([np.array(list(zip(x, x[1:]))).ravel() for x in wm.node2vec.walks])\n walks = np.reshape(res, (n_transitions, 2))\n\n pairs = pd.DataFrame({'state1': walks[:, 0], 'state2': walks[:, 1]})\n counts = pairs.groupby('state1')['state2'].value_counts().unstack()\n counts = counts.replace(np.nan, 0)\n assert pairs.shape == (n_nodes * (w_config['walk_length'] - 1) * w_config['num_walks'], 2)\n assert counts.iloc[5][4] == 0\n assert counts.iloc[4][5] != 0\n assert len(set(edges['source_content_id']).union(\n set(edges['destination_content_id']))) == len(wm.model.wv.vocab.keys())","def count_edges(input_first, input_second, problem):\n\tcount = 0\n\tfor idx in xrange(len(input_first)):\n\t\tfor index in xrange(len(input_second)):\n\t\t\tif (input_first[idx], input_second[index]) in problem:\n\t\t\t\tcount += 1\n\t\t\telif (input_second[index], input_first[idx]) in problem:\n\t\t\t\tcount += 1\n\treturn count","def get_no_of_annotations(database, label, train_vids_all):\n count = 0\n for vid in train_vids_all:\n for ann in database[vid]['annotations']:\n if ann['label'] == label:\n count += 1\n return count","def Nedges(self):\n return len(self.edges)","def neighbor_count(A):\n sum2 = lambda A, B: map2(add, A, B)\n neighbors = ((-1, -1), (-1, 0), (-1, 1),\n (0, -1), (0, 1),\n (1, -1), (1, 0), (1, 1))\n return reduce(sum2,\n map(lambda d: rotate2(A, d[0], d[1]),\n neighbors))","def num_links(self):\n count=0.0\n for cluster in self.clusters:\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\n numberofmembers=self.clusters[cluster].number_of_members\n count+=numberofmembers\n return count","def number_of_connections(self, asn):\n customer_count = 0\n provider_count = 0\n peer_count = 0\n\n for neighbor in nx.all_neighbors(self, asn):\n edge_data = self.get_edge_data(asn, neighbor)\n if edge_data[\"relationship\"] == -1 and edge_data[\"as1\"] == asn:\n customer_count += 1\n elif edge_data[\"relationship\"] == -1 and edge_data[\"as2\"] == asn:\n provider_count += 1\n elif edge_data[\"relationship\"] == 0:\n peer_count += 1\n return customer_count, provider_count, peer_count","def clear_mappings(g, source):\n\n if \"m\" in g.node[source]:\n del g.node[source][\"m\"]\n\n for n in g.neighbors_iter(source):\n if \"m\" in g.node[n]:\n del g.node[n][\"m\"]","def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))","def size(self):\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))","def num_edges(self):\n return sum(len(v.adj) for v in self.vertices.values())","def multi_edge():\n from networkx.readwrite import json_graph\n import networkx as nx\n import autonetkit\n # returns a house graph\n data = {'directed': False,\n 'graph': [],\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 1},\n {'_ports': {'r2': 3, 'r4': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r2': 4, 'r4': 3},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r3': 3, 'r5': 2},\n 'raw_interfaces': {},\n 'source': 1,\n 'target': 4},\n {'_ports': {'r1': 1, 'r2': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 3, 'r2': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 2, 'r3': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 4, 'r3': 4},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 5, 'r3': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r2': 2, 'r3': 2},\n 'raw_interfaces': {},\n 'source': 3,\n 'target': 4}],\n 'multigraph': True,\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r4',\n 'label': 'r4',\n 'x': 675,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r5',\n 'label': 'r5',\n 'x': 675,\n 'y': 500},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r1',\n 'label': 'r1',\n 'x': 350,\n 'y': 400},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r2',\n 'label': 'r2',\n 'x': 500,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r3',\n 'label': 'r3',\n 'x': 500,\n 'y': 500}]}\n graph = json_graph.node_link_graph(data)\n anm = autonetkit.anm.NetworkModel()\n g_in = anm.add_overlay(\"input\")\n g_in._replace_graph(nx.MultiGraph(graph))\n # TODO: check if should build overlays here rather than clone in?\n g_phy = anm[\"phy\"]\n g_phy._replace_graph(graph)\n return anm","def edge_count(self):\n total = sum(len(self._outgoing[v]) for v in self._outgoing)\n # for undirected graphs, make sure not to double-count edges\n return total if self.is_directed() else total // 2","def terminals(self):\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\n return unique_nodes[ unique_counts == 1 ]","def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses","def get_nodes_pixel_count(self):\n sum_count = self.pixel_count\n for i in range(8):\n node = self.children[i]\n if node:\n sum_count += node.pixel_count\n return sum_count","def totalConnections(analyzer):\n return model.totalConnections(analyzer)","def ray_label_simplex(grid, simplex, thresh):\n coords = [grid[:,x] for x in simplex]\n dist = squareform(pdist(coords,'euclidean'))\n adjacency = dist<thresh\n adjacency = adjacency.astype(int) \n graph = csr_matrix(adjacency)\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n\n return n_components","def graph_to_input_target(graph):\n\n def create_feature(attr, fields):\n return np.hstack([np.array(attr[field], dtype=float) for field in fields])\n\n input_node_fields = (\"pos\", \"start\", \"end\")\n input_edge_fields = (\"distance\",)\n target_node_fields = (\"solution\",)\n target_edge_fields = (\"solution\",)\n\n input_graph = graph.copy()\n target_graph = graph.copy()\n\n solution_length = 0\n for node_index, node_feature in graph.nodes(data=True):\n input_graph.add_node(\n node_index, features=create_feature(node_feature, input_node_fields))\n target_node = to_one_hot(\n create_feature(node_feature, target_node_fields).astype(int), 2)[0]\n target_graph.add_node(node_index, features=target_node)\n solution_length += int(node_feature[\"solution\"])\n solution_length /= graph.number_of_nodes()\n\n for receiver, sender, features in graph.edges(data=True):\n input_graph.add_edge(\n sender, receiver, features=create_feature(features, input_edge_fields))\n target_edge = to_one_hot(\n create_feature(features, target_edge_fields).astype(int), 2)[0]\n target_graph.add_edge(sender, receiver, features=target_edge)\n\n input_graph.graph[\"features\"] = np.array([0.0])\n target_graph.graph[\"features\"] = np.array([solution_length], dtype=float)\n\n return input_graph, target_graph","def count_target(self):\n tally = {}\n for obj in self.target:\n tally[obj] = 0\n\n ind = 0\n for label in self.labelList:\n filename = self.pathLabel + label\n f = open(filename, 'r')\n content = f.read().split('\\n')\n for line in content:\n items = line.split(' ')\n if items[0] in self.target:\n tally[items[0]] += 1\n f.close()\n if ind % 100 == 0:\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\n ind += 1\n \n print('[COUNT] done counting targets in dataset')\n print(tally)","def fill_count(nid):\n n_edges = G.subgraph(G.neighbors(nid)).number_of_edges()\n deg = G.degree[nid]\n n_fill = deg*(deg-1)//2 - n_edges\n return n_fill","def num_nodes(g):\n return len(g.keys())","def num_edges(graph1: list, graph2: list):\n check1 = 0\n check2 = 0\n for row, _ in enumerate(graph1):\n for column, _ in enumerate(graph1[row]):\n if graph1[row][column] == 1:\n check1 += 1\n if graph2[row][column] == 1:\n check2 += 1\n return check1 == check2","def countNeighbors(oldgen, x, y):\n temp = 1\n\n count = 0\n for i in range(-1, 2):\n for j in range(-1, 2):\n\n # TODO: this needs rewritin to be more understandable\n if not (i == 0 and j == 0):\n count += int(oldgen[(x + i + WID) % WID][(y + j + HGT) % HGT])\n\n for i in range(-1, 2):\n for j in range(-1, 2):\n temp += 1\n\n count -= int(oldgen[x][y])\n\n return count","def edge_count(self):\r\n return int(sum(self.degree(node) for node in range(self.size))/2)","def _num_conn_comp(graph):\n\n return nx.number_connected_components(graph)","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def _num_edges(self):\n return int(self._edge_map[-1])","def edge_status(g, source, target):\n edge = source, target, g.graph['edge_key']\n if edge in g.graph['negatives']:\n status = 0\n elif edge in g.graph['positives']:\n status = 1\n else:\n status = int(g.has_edge(*edge)) + 2\n return status","def get_node_count(self) -> Iterable:\n return self._g.V().count().toList()[0]","def compute_num_nodes(graph):\n return len(graph.keys()) # return the number of nodes in the graph","def neato_graph_from_corpus( corpus, max_nodes ) :\n\n O, row_dois, column_dois = cites_matrix( corpus )\n neato_cooccurrence_graph( O, column_dois )\n return None\n\n \n v = total_occurrences( O ) \n nv = v.astype( float32 ) / v.max()\n C = cooccurrence_matrix ( O )\n nC = normalized_cooccurrence_matrix( O )\n\n # now find our cutoff!\n # find the max number of cocites and start there\n cocite_cutoff = C.max()\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\n # then reduce the number until we exceed max_nodes\n while num_nodes < max_nodes :\n cocite_cutoff = cocite_cutoff - 1\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\n\n if num_nodes > max_nodes :\n cocite_cutoff = cocite_cutoff + 1\n \n C = C.copy()\n C[ C < cocite_cutoff ]= 0\n\n graph = pydot.Dot( graph_type = 'graph' )\n graph.set_overlap(\"false\")\n coords = zip(*(C >= cocite_cutoff).nonzero())\n\n # make a dict of all nodes which are mentioned in the coords\n nodes = {}\n index = 1\n for coord in set(chain.from_iterable(coords)) :\n if not nodes.has_key( coord ) :\n node = pydot.Node( str(coord) )\n if v != None :\n doi = column_dois[coord]\n node.set_label( str(index) )\n node.set_penwidth( nv[ coord ] )\n node.set_fixedsize(\"true\")\n node.set_width( 1.0 *nv[ coord ] )\n #node.set_shape(\"circle\")\n nodes[ coord ] = node\n graph.add_node( node )\n index = index + 1\n\n for coord in coords :\n \n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\n edge.set_weight( nC[coord] )\n edge.set_penwidth( nC[coord]*5 )\n #edge.set_label( str(int(m[coord]) ))\n graph.add_edge(edge)\n\n \n legend = pydot.Node( \"legend\" )\n nodelist = nodes.items()\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\n legend.set_label( \"\\l\".join([x[1].get_label()+\":\"+column_dois[x[0]] for x in nodelist])+\"\\l\" )\n legend.set_shape(\"box\")\n graph.add_node(legend)\n\n print graph.to_string()\n #graph.write_dot('test.dot', prog='neato' )\n #graph.write_png('test.png', prog='neato' )\n #graph.write_pdf('test.pdf', prog='neato' )","def get_annotations(graph):\n return set(_annotation_iter_helper(graph))","def node_size(graph):\n adj = nx.betweenness_centrality(graph)\n return np.array([x * 1e3 for x in adj.values()])","def get_unused_annotations(graph):\n return graph.defined_annotation_keywords - get_annotations(graph)"],"string":"[\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def compute_num_edges(graph):\\n # return the number of edges\\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2\",\n \"def count_annotation_values(graph, annotation):\\n return Counter(iter_annotation_values(graph, annotation))\",\n \"def __filterEdges(self):\",\n \"def count_nodes(self, term=None, labels: istr = None):\",\n \"def get_indegrees(graph: Graph):\\n transpose = get_transpose_graph(graph)\\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}\",\n \"def count_nodes(self, term=None, labels: istr = None) -> int:\",\n \"def proximal_neighbor_count(source : Image, destination : Image = None, min_distance : float = 0, max_distance : float = np.finfo(np.float32).max) -> Image:\\n from .._tier1 import set_column\\n from .._tier9 import centroids_of_labels\\n from .._tier1 import generate_distance_matrix\\n from .._tier3 import generate_proximal_neighbors_matrix\\n from .._tier1 import count_touching_neighbors\\n\\n pointlist = centroids_of_labels(source)\\n distance_matrix = generate_distance_matrix(pointlist, pointlist)\\n\\n touch_matrix = generate_proximal_neighbors_matrix(distance_matrix, min_distance=min_distance, max_distance=max_distance)\\n destination = count_touching_neighbors(touch_matrix, destination)\\n set_column(destination, 0, 0)\\n return destination\",\n \"def init_inbound_counts(nodes, edges):\\n inbound_counts = {}\\n for node in nodes:\\n inbound_counts[node] = 0\\n for e in edges:\\n inbound_counts[e[1]] = inbound_counts[e[1]] + 1\\n return inbound_counts\",\n \"def num_ad_pruning(edge_list=\\n path+'connected-component-analysis-round2/network-profiling-data/cid6_analysis/cid6-edge-list',\\n worker_ads_file = path+'connected-component-analysis-round2/network-profiling-data/cid6_analysis/worker-ads-int-dict.json'):\\n G = nx.read_edgelist(edge_list, delimiter='\\\\t')\\n worker_ints = json.load(open(worker_ads_file, 'r'))\\n print nx.info(G)\\n threshold = 16\\n count = 0\\n forbidden_phones = set()\\n # with codecs.open(edge_phone_count, 'r', 'utf-8') as f:\\n # for line in f:\\n # obj = json.loads(line[0:-1])\\n # if int(obj.keys()[0]) >= threshold:\\n # forbidden_phones = forbidden_phones.union(set(obj[obj.keys()[0]]))\\n # with codecs.open(phone_edge_list, 'r', 'utf-8') as f:\\n # for line in f:\\n # fields = re.split('\\\\t', line[0:-1])\\n # phones = set(fields[2:])\\n # if len(phones.intersection(forbidden_phones)) != 0:\\n # count += 1\\n # G.remove_edge(fields[0], fields[1])\\n H = nx.Graph()\\n for e in G.edges:\\n if e[0] not in worker_ints or e[1] not in worker_ints:\\n raise Exception\\n else:\\n if len(worker_ints[e[0]]) < threshold and len(worker_ints[e[1]]) < threshold:\\n H.add_edge(e[0], e[1])\\n else:\\n count += 1\\n print str(count),' edges pruned from graph'\\n print nx.info(H)\\n ccs = sorted(nx.connected_components(H), key=len, reverse=True)\\n print len(ccs)\\n print len(ccs[0])\",\n \"def edgecount(self):\\n\\n raise NotImplementedError\",\n \"def count_relations(graph):\\n return Counter(\\n data[RELATION]\\n for _, _, data in graph.edges_iter(data=True)\\n )\",\n \"def sum_edges(g, source, hops):\\n\\n edges = 0\\n\\n paths = nx.single_source_shortest_path(g, source, hops)\\n for node in paths.iterkeys():\\n edges += len(g.neighbors(node))\\n\\n return edges\",\n \"def num_edges(g):\\n total_edges_with_duplicates = sum(len(v) for v in g.values())\\n return total_edges_with_duplicates // 2\",\n \"def reduce_inbound_connections(inbound_counts, nodes):\\n nodes_without_inbound = []\\n for node in nodes:\\n inbound_counts[node] = inbound_counts[node] - 1\\n if inbound_counts[node] == 0:\\n nodes_without_inbound.append(node)\\n return nodes_without_inbound\",\n \"def count_unique_relations(graph):\\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))\",\n \"def street_segment_count(Gu):\\n if nx.is_directed(Gu): # pragma: no cover\\n msg = \\\"`Gu` must be undirected\\\"\\n raise ValueError(msg)\\n return len(Gu.edges)\",\n \"def local_node_connectivity(G, source, target, cutoff=None):\\n if target == source:\\n raise nx.NetworkXError(\\\"source and target have to be different nodes.\\\")\\n\\n # Maximum possible node independent paths\\n if G.is_directed():\\n possible = min(G.out_degree(source), G.in_degree(target))\\n else:\\n possible = min(G.degree(source), G.degree(target))\\n\\n K = 0\\n if not possible:\\n return K\\n\\n if cutoff is None:\\n cutoff = INF\\n\\n exclude = set()\\n for i in range(min(possible, cutoff)):\\n try:\\n path = _bidirectional_shortest_path(G, source, target, exclude)\\n exclude.update(set(path))\\n K += 1\\n except nx.NetworkXNoPath:\\n break\\n\\n return K\",\n \"def nodes_per_time_step(graphs: typ.Iterable[vtna.graph.Graph]) -> typ.List[int]:\\n return [len(set(node for edge in graph.get_edges() for node in edge.get_incident_nodes())) for graph in graphs]\",\n \"def return_num_edges(self):\\n return sum(map(lambda x: len(x),self.__adj))\",\n \"def _prune_graph(self, graph, target_graph):\\n count = 1\\n _logger.debug(\\n '|----+----------------------------------------+------------------------------+------------------------------|'\\n )\\n _logger.debug('|{:^4}|{:^40}|{:^30}|{:^30}|'.format('id', 'parammeter',\\n 'from', 'to'))\\n for param in target_graph.all_parameters():\\n var = graph.var(param.name())\\n ori_shape = var.shape()\\n var.set_shape(param.shape())\\n _logger.debug(\\n '|----+----------------------------------------+------------------------------+------------------------------|'\\n )\\n _logger.debug('|{:^4}|{:^40}|{:^30}|{:^30}|'.format(\\n str(count),\\n str(param.name()), str(ori_shape), str(param.shape())))\\n count += 1\\n _logger.debug(\\n '|----+----------------------------------------+------------------------------+------------------------------|'\\n )\",\n \"def control_edge_count(self) -> int:\\n return int(self.graph_tuple_stats.control_edge_count or 0)\",\n \"def test_count_neighbors(self):\\n m, n = 5, 5\\n k, p = 0.2, 0.7\\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\\n C = ConwayModel(m, n, k, p, agents)\\n\\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\\n result = C.count_neighbors(to_count)\\n self.assertTrue(np.all(expected == result))\",\n \"def count_fillin(graph, nodes):\\n count = 0\\n for v1 in nodes:\\n for v2 in nodes:\\n if v1 != v2 and v2 not in graph[v1]:\\n count += 1\\n return count / 2\",\n \"def intersection_count(G=None, min_streets=2):\\n spn = streets_per_node(G)\\n node_ids = set(G.nodes)\\n return sum(count >= min_streets and node in node_ids for node, count in spn.items())\",\n \"def _num_edges(self):\\n return len(self._eid2partid)\",\n \"def get_nb_edit_operations(g1, g2, forward_map, backward_map):\\n n_vi = 0\\n n_vr = 0\\n n_vs = 0\\n n_ei = 0\\n n_er = 0\\n n_es = 0\\n\\n nodes1 = [n for n in g1.nodes()]\\n for i, map_i in enumerate(forward_map):\\n if map_i == np.inf:\\n n_vr += 1\\n elif g1.nodes[nodes1[i]]['atom_symbol'] != g2.nodes[map_i]['atom_symbol']:\\n n_vs += 1\\n for map_i in backward_map:\\n if map_i == np.inf:\\n n_vi += 1\\n\\n# idx_nodes1 = range(0, len(node1))\\n\\n edges1 = [e for e in g1.edges()]\\n nb_edges2_cnted = 0\\n for n1, n2 in edges1:\\n idx1 = nodes1.index(n1)\\n idx2 = nodes1.index(n2)\\n # one of the nodes is removed, thus the edge is removed.\\n if forward_map[idx1] == np.inf or forward_map[idx2] == np.inf:\\n n_er += 1\\n # corresponding edge is in g2. Edge label is not considered.\\n elif (forward_map[idx1], forward_map[idx2]) in g2.edges() or \\\\\\n (forward_map[idx2], forward_map[idx1]) in g2.edges():\\n nb_edges2_cnted += 1\\n # corresponding nodes are in g2, however the edge is removed.\\n else:\\n n_er += 1\\n n_ei = nx.number_of_edges(g2) - nb_edges2_cnted\\n\\n return n_vi, n_vr, n_vs, n_ei, n_er, n_es\",\n \"def _scan_targets(self, indices_to_nodes, node_property, source_index,\\n factor_aggregator, compute_statistics,\\n total_factor_instances,\\n generated_edges, reverse_edges=False, limit=None,\\n verbose=False):\\n edge_list = []\\n for target_index in range(source_index + 1, len(indices_to_nodes)):\\n s = indices_to_nodes[source_index]\\n t = indices_to_nodes[target_index]\\n\\n if node_property is not None:\\n s_factors, t_factors = self._get_node_factors(\\n s, t, node_property, factor_aggregator)\\n else:\\n if factor_aggregator is None:\\n factor_aggregator = aggregate_index\\n s_factors, t_factors = self._get_edge_factors(\\n s, t, factor_aggregator, reverse_edges)\\n\\n common_factors = safe_intersection(\\n s_factors, t_factors)\\n\\n if len(common_factors) > 0:\\n edge = {\\n \\\"@source_id\\\": s,\\n \\\"@target_id\\\": t,\\n \\\"common_factors\\\": common_factors\\n }\\n\\n for stat in compute_statistics:\\n edge[stat] = COOCCURRENCE_STATISTICS[stat](\\n self.pgframe, s, t,\\n node_property,\\n common_factors,\\n total_factor_instances,\\n factor_aggregator,\\n reverse_edges)\\n\\n edge_list.append(edge)\\n\\n if limit:\\n if len(generated_edges) + len(edge_list) == limit:\\n if verbose:\\n print(\\\"Reached the edge limit ({})\\\".format(limit))\\n return edge_list\\n\\n return edge_list\",\n \"def node_count(self) -> int:\\n return int(self.graph_tuple_stats.node_count or 0)\",\n \"def num_edges(self):\\n return sum(1 for _ in self.iteredges())\",\n \"def count_unvisited(data):\\n count = sum(n.count(\\\"n\\\") for n in data)\\n return count\",\n \"def edge_count(self) -> int:\\n return int(self.graph_tuple_stats.edge_count or 0)\",\n \"def numShortestPaths(g, start, end):\\n if g == None or start == None or end == None:\\n raise InvalidInputException(\\\"Input is null.\\\")\\n if not g.containsVertex(start) or not g.containsVertex(end):\\n raise InvalidInputException(\\\"Doesn't contain source.\\\")\\n nodes = []\\n nodes.append(start)\\n # Adds two decorations to the vertices\\n for node in g.iterVertices():\\n node.minCount = float(\\\"inf\\\")\\n node.numCount = 0\\n start.minCount = 0\\n while not len(nodes) == 0:\\n node = nodes.pop(0)\\n # Base case: if node is the end node, return the numCount decoration\\n if node == end:\\n return node.numCount\\n # Decorates neighboring nodes and adds them to the list\\n for edge in g.incidentEdges(node):\\n new_node = g.opposite(node,edge)\\n if new_node.minCount == float(\\\"inf\\\"):\\n new_node.minCount = node.minCount+1\\n nodes.append(new_node)\\n if new_node.minCount == node.minCount + 1:\\n new_node.numCount = node.numCount + 1\",\n \"def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)\",\n \"def find_nodes(shp):\\n node_count = {}\\n for road in shp:\\n vrts = road.vertices\\n for node in vrts:\\n if node not in node_count:\\n node_count[node] = 0\\n node_count[node] += 1\\n node_count[vrts[0]] += 1\\n node_count[vrts[-1]] += 1\\n return set([node for node,c in node_count.iteritems() if c > 1])\",\n \"def count_nodes(self):\\n\\t\\treturn self.__count_nodes(self)\",\n \"def add_neighbor_count_features(edge_df, X_df, structures_df):\\n cnt_df = edge_df.groupby(\\n ['molecule_name', 'atom_index_0']).size().to_frame('EF_neighbor_count')\\n cnt_df.reset_index(inplace=True)\\n cnt_df.rename({'atom_index_0': 'atom_index_zero'}, inplace=True, axis=1)\\n\\n X_df = X_df.reset_index()\\n X_df = pd.merge(\\n X_df,\\n cnt_df,\\n how='left',\\n left_on=['molecule_name', 'atom_index_1'],\\n right_on=['molecule_name', 'atom_index_zero'])\\n\\n X_df.rename({\\n 'EF_neighbor_count': 'EF_atom_index_1_neighbor_count'\\n },\\n inplace=True,\\n axis=1)\\n X_df.drop(['atom_index_zero'], inplace=True, axis=1)\\n X_df.set_index('id', inplace=True)\\n incorrect_absence = 100 * X_df['EF_atom_index_1_neighbor_count'].isna(\\n ).sum() / X_df.shape[0]\\n print('[EdgeFeatures] Setting following percentage of edges to 0:',\\n incorrect_absence)\\n\\n X_df['EF_atom_index_1_neighbor_count'] = X_df[\\n 'EF_atom_index_1_neighbor_count'].fillna(0).astype(np.uint8)\\n return X_df\",\n \"def _count_discordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\\n return torch.cat([_discordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)\",\n \"def num_edges_rows(graph):\\n return len(graph.graph.edges), len(graph.graph.nodes)\",\n \"def node_graph(imageSkeleton, imageGaussian):\\n ones = np.ones((3, 3))\\n imageFiltered = sp.ndimage.generic_filter(imageSkeleton, node_find, footprint=ones, mode='constant', cval=0)\\n imageNodeCondense = node_condense(imageFiltered, imageGaussian, ones)\\n imageLabeledNodes = skimage.segmentation.relabel_sequential(imageNodeCondense)[0]\\n imageLabeledSkeleton, labels = sp.ndimage.label(imageSkeleton, structure=ones)\\n for label in range(1, labels + 1):\\n detectedNodes = np.max((imageLabeledSkeleton == label) * (imageLabeledNodes > 0))\\n if (detectedNodes == 0):\\n imageSkeleton[imageLabeledSkeleton == label] = 0\\n imageAnnotated = 1 * ((imageSkeleton + imageLabeledNodes) > 0) + imageLabeledNodes\\n return(imageAnnotated)\",\n \"def guess_num_nodes_from(edgelist):\\n return np.max(edgelist) + 1\",\n \"def _number_of_edges(self):\\n if self._edges is None:\\n return 0\\n return len(self._edges)\",\n \"def num_of_edge(self):\\n try:\\n return self.edges\\n except:\\n print(\\\"ERROR: No graph exists\\\")\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\",\n \"def num_cusps_of_regions(self):\\n G = self._get_puncturefinder_graph()\\n # return [sum(G.subgraph(vertices=region).edge_labels())\\n # for region in G.connected_components()]\\n return [sum(edge[2]['weight']\\n for edge in subgraph.edges(data=True))\\n for subgraph in nx.connected_component_subgraphs(G)]\",\n \"def getNumMarkedTargets(self):\\n return len(self.getConTextModeNodes(\\\"target\\\"))\",\n \"def getNumMarkedTargets(self):\\n return len(self.getConTextModeNodes(\\\"target\\\"))\",\n \"def make_graph(imageAnnotated, imageGaussian):\\n nodeNumber = imageAnnotated.max() - 1\\n distanceDiagonalPixels, distanceDiagonalPixelsCubic = np.sqrt(2.0), np.sqrt(3.0)\\n distanceMatrix = np.array([[distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic], [distanceDiagonalPixels, 1, distanceDiagonalPixels],\\n [distanceDiagonalPixelsCubic, distanceDiagonalPixels, distanceDiagonalPixelsCubic]])\\n nodePositions = np.transpose(np.where(imageAnnotated > 1))[:, ::-1]\\n imagePropagatedNodes = imageAnnotated.copy()\\n imageFilamentLength = 1.0 * (imageAnnotated.copy() > 0)\\n imageFilamentIntensity = 1.0 * (imageAnnotated.copy() > 0)\\n dimensionY, dimensionX = imageAnnotated.shape\\n filament = (imagePropagatedNodes == 1).sum()\\n while (filament > 0):\\n nodePixel = np.transpose(np.where(imagePropagatedNodes > 1))\\n for posY, posX in nodePixel:\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n nodeNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax]\\n nodeFilamentLength = imageFilamentLength[yMin:yMax, xMin:xMax]\\n nodeFilamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax]\\n imagePropagatedNodes[yMin:yMax, xMin:xMax] = np.where(nodeNeighborhood == 1, imagePropagatedNodes[posY, posX], nodeNeighborhood)\\n imageFilamentLength[yMin:yMax, xMin:xMax] = np.where(nodeFilamentLength == 1, distanceMatrix[0:yMax - yMin, 0:xMax - xMin] + imageFilamentLength[posY, posX], nodeFilamentLength)\\n imageFilamentIntensity[yMin:yMax, xMin:xMax] = np.where(nodeFilamentIntensity == 1, imageGaussian[posY, posX] + imageFilamentIntensity[posY, posX], nodeFilamentIntensity)\\n filament = (imagePropagatedNodes == 1).sum()\\n graph = nx.empty_graph(nodeNumber, nx.MultiGraph())\\n filamentY, filamentX = np.where(imagePropagatedNodes > 1)\\n for posY, posX in zip(filamentY, filamentX):\\n nodeIndex = imagePropagatedNodes[posY, posX]\\n xMin, xMax, yMin, yMax = bounds(posX - 1, 0, dimensionX), bounds(posX + 2, 0, dimensionX), bounds(posY - 1, 0, dimensionY), bounds(posY + 2, 0, dimensionY)\\n filamentNeighborhood = imagePropagatedNodes[yMin:yMax, xMin:xMax].flatten()\\n filamentLength = imageFilamentLength[yMin:yMax, xMin:xMax].flatten()\\n filamentIntensity = imageFilamentIntensity[yMin:yMax, xMin:xMax].flatten()\\n for index, pixel in enumerate(filamentNeighborhood):\\n if (pixel != nodeIndex and pixel > 1):\\n node1, node2 = np.sort([nodeIndex - 2, pixel - 2])\\n nodeDistance = sp.linalg.norm(nodePositions[node1] - nodePositions[node2])\\n filamentLengthSum = imageFilamentLength[posY, posX] + filamentLength[index]\\n filamentIntensitySum = imageFilamentIntensity[posY, posX] + filamentIntensity[index]\\n minimumEdgeWeight = max(1e-9, filamentIntensitySum)\\n edgeCapacity = 1.0 * minimumEdgeWeight / filamentLengthSum\\n edgeLength = 1.0 * filamentLengthSum / minimumEdgeWeight\\n edgeConnectivity = 0\\n edgeJump = 0\\n graph.add_edge(node1, node2, edist=nodeDistance, fdist=filamentLengthSum, weight=minimumEdgeWeight, capa=edgeCapacity, lgth=edgeLength, conn=edgeConnectivity, jump=edgeJump)\\n return(graph, nodePositions)\",\n \"def essential_node_count(self) -> int:\\n return sum(\\n 1 for n in self.graph.nodes() if n.kind() not in self._EXCLUDED_NODE_KINDS\\n )\",\n \"def streets_per_node(G):\\n spn = dict(nx.get_node_attributes(G, \\\"street_count\\\"))\\n if set(spn) != set(G.nodes):\\n utils.log(\\\"Graph nodes changed since `street_count`s were calculated\\\", level=lg.WARN)\\n return spn\",\n \"def edge_sig(T, source=[], target=[], type_='out'):\\n case_cnt = sum([v[0] for v in T['start'].values()])\\n S = dict()\\n for a_i in source:\\n S[a_i] = dict()\\n target_ = T if type_ != 'out' else T[a_i]\\n for a_j in target_:\\n if (a_i == a_j) | (a_j not in target): continue\\n if type_ != 'out':\\n if a_i in T[a_j]: S[a_i][a_j] = T[a_j][a_i][1] / case_cnt\\n else: S[a_i][a_j] = T[a_i][a_j][1] / case_cnt\\n return S\",\n \"def Features(src, dest): \\n # find common nodes of x and y\\n common_out_x = out_edges.get(src,set())\\n common_out_y = out_edges.get(dest, set())\\n common_in_x = in_edges.get(src, set())\\n common_in_y = in_edges.get(dest, set())\\n\\n\\n intersection = (common_in_x|common_out_x) & \\\\\\n (common_in_y|common_out_y)\\n union = (common_in_x|common_out_x) | \\\\\\n (common_in_y|common_out_y)\\n\\n # cosine similarity\\n connected_x = common_out_x | common_in_x\\n connected_y = common_out_y | common_in_y\\n prod_xy = float(len(connected_x)*len(connected_y))\\n cosine = len(intersection) / prod_xy if prod_xy != 0.0 else 0\\n\\n # jaccard\\n jaccard = float(len(intersection)) / len(union) \\\\\\n if len(union) > 0 else 0\\n\\n jaccard_mutate = Jaccard(dest, out_edges.get(src))\\n\\n #\\n # compute the adamic/adar value of source node and\\n # destination node\\n adar_set = 0\\n for z in intersection:\\n degrees = 0\\n # degrees of a common node\\n if out_edges.get(z):\\n degrees += len(out_edges[z]) \\n if in_edges.get(z):\\n degrees += len(in_edges[z]) \\n\\n if degrees != 0:\\n adar_set += 1 / log(degrees)\\n\\n # preferential attachment\\n pref_attach = len(connected_x) * len(connected_y)\\n\\n # kn1\\n w_src_out = 1 / sqrt(1+len(common_out_x))\\n w_dest_in = 1 / sqrt(1+len(common_in_y))\\n w_kn1 = w_src_out * w_dest_in\\n\\n\\n #return [len(common_out_x), len(common_in_y), jaccard, adar_set]\\n return [src,\\n dest,\\n len(common_out_x),\\n len(common_in_x),\\n len(common_out_y),\\n len(common_in_y), \\n len(intersection),\\n cosine,\\n jaccard,\\n jaccard_mutate,\\n adar_set,\\n pref_attach,\\n w_kn1]\",\n \"def clean_edges(self):\",\n \"def number_active_neighbors(graph, node):\\n return np.sum(\\n [\\n graph.nodes[neighbor_idx][\\\"agent\\\"].active\\n for neighbor_idx in graph[node].keys()\\n ]\\n )\",\n \"def __init__(self, graph, source=1, target=33):\\n super().__init__(\\\"Path length\\\")\\n self.source = source\\n self.target = target\\n self.graph = graph.copy()\\n self.ind_dict = {}\\n for i, (u, v) in enumerate(self.graph.edges):\\n self.ind_dict[i] = (u, v)\",\n \"def _count_bipartite_edges(G, X, Y):\\n cpt = 0\\n for edge in G.edges:\\n v1 = edge.v1\\n v2 = edge.v2\\n if (X.__contains__(v1) and Y.__contains__(v2)) or (X.__contains__(v2) and Y.__contains__(v1)):\\n cpt += 1\\n return cpt\",\n \"def hypergraph_common_edges(u, v, hypergraph):\\n total = 0\\n for e in hypergraph.edges():\\n if u in e.elements and v in e.elements:\\n total += 1\\n return total\",\n \"def count_streets_per_node(G, nodes=None):\\n if nodes is None:\\n nodes = G.nodes\\n\\n # get one copy of each self-loop edge, because bi-directional self-loops\\n # appear twice in the undirected graph (u,v,0 and u,v,1 where u=v), but\\n # one-way self-loops will appear only once\\n Gu = G.to_undirected(reciprocal=False, as_view=True)\\n self_loop_edges = set(nx.selfloop_edges(Gu))\\n\\n # get all non-self-loop undirected edges, including parallel edges\\n non_self_loop_edges = [e for e in Gu.edges(keys=False) if e not in self_loop_edges]\\n\\n # make list of all unique edges including each parallel edge unless the\\n # parallel edge is a self-loop, in which case we don't double-count it\\n all_unique_edges = non_self_loop_edges + list(self_loop_edges)\\n\\n # flatten list of (u, v) edge tuples to count how often each node appears\\n edges_flat = itertools.chain.from_iterable(all_unique_edges)\\n counts = Counter(edges_flat)\\n streets_per_node = {node: counts[node] for node in nodes}\\n\\n utils.log(\\\"Counted undirected street segments incident on each node\\\")\\n return streets_per_node\",\n \"def read_graph(args):\\n dataset = pd.read_csv(args.features_path).values.tolist()\\n edges = {}\\n edges[\\\"positive_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == 1]\\n edges[\\\"negative_edges\\\"] = [edge[0:2] for edge in dataset if edge[2] == -1]\\n edges[\\\"ecount\\\"] = len(dataset)\\n edges[\\\"ncount\\\"] = len(set([edge[0] for edge in dataset]+[edge[1] for edge in dataset]))\\n return edges\",\n \"def num_edges(self):\\r\\n return len(self.__generate_edges())\",\n \"def get_node_count(self) -> Iterable:\\n return len([i for i in self.all_nodes_as_iterable()])\",\n \"def countEdges(self):\\n return numpy.count_nonzero(self.supportArray) / 2\",\n \"def edge_mapping(self):\\n ...\",\n \"def prepare_graph(label, nodes, edges, graphID):\\n features = {'label': label}\\n\\n G = nx.DiGraph()\\n nodes[\\\"id\\\"] = nodes[\\\"id\\\"].apply(lambda x : str(x))\\n features['num_nodes'] = nodes.shape[0]\\n op_node = None\\n times = []\\n friends = []\\n followers = []\\n for index, row in nodes.iterrows():\\n G.add_node(row['id'], time=row['time'], friends=row['friends'], followers = row['followers'])\\n times.append(row['time'])\\n friends.append(2**row['friends'])\\n followers.append(2**row['followers'])\\n if row['time'] == 0:\\n features['poster_friend_cnt'] = 2**row['friends']\\n features['poster_follower_cnt'] = 2**row['followers']\\n tweeter_id = row['id']\\n op_node = row['id']\\n features['avg_time'] = np.mean(times)\\n features['avg_friends'] = np.mean(friends)\\n features['avg_followers'] = np.mean(followers)\\n features['max_followers'] = max(followers)\\n features['max_friends'] = max(friends)\\n features['friends_25th_percentile'] = np.percentile(friends, 25)\\n features['friends_75th_percentile'] = np.percentile(friends, 75)\\n features['followers_25th_percentile'] = np.percentile(followers, 25)\\n features['followers_75th_percentile'] = np.percentile(followers, 75)\\n node_list = []\\n edge_count = 0\\n for pair in edges:\\n node1, node2 = pair.split()[0], pair.split()[1]\\n node_list.append(node1)\\n node_list.append(node2)\\n G.add_edge(node1, node2)\\n edge_count += 1\\n features['num_edges'] = edge_count\\n sum_users_without_followers = sum([1 for (node, val) in G.in_degree() if val==0])\\n features['ratio_users_w/out_followers'] = sum_users_without_followers / len(G.nodes)\\n features['num_connected_components'] = nx.number_strongly_connected_components(G)\\n features['number_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id)\\n features['percentage_of_OPs_followers_who_retweeted'] = G.in_degree(tweeter_id) / features['poster_follower_cnt']\\n features['avg_clustering'] = nx.average_clustering(G)\\n features['op_clustering'] = nx.clustering(G,op_node)\\n features['transitivity'] = nx.transitivity(G)\\n node_list = list(set(node_list))\\n features['nodeID_list'] = np.array(node_list)\\n features['graph_id'] = graphID\\n return features, G\",\n \"def edge_count(adjList):\\n edges = {}\\n for id, neigh in enumerate(adjList):\\n for n in neigh:\\n edges[max(n, id), min(n, id)] = id\\n\\n return len(edges)\",\n \"def test_node_sampling(weighted_graph_config_fixture):\\n w_config = weighted_graph_config_fixture\\n\\n # Node 5 to node 4 has zero weight (zero transition probability)\\n # Node 4 to node 5 has ten weight (high transition probability)\\n edges = pd.DataFrame({'source_content_id': [0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5],\\n 'destination_content_id': [5, 1, 0, 3, 4, 1, 2, 1, 3, 5, 3, 4],\\n 'weight': [1, 2, 3, 4, 1, 2, 3, 4, 1, 10, 5, 0]}\\n )\\n wm = N2VModel()\\n\\n wm.create_graph(edges, w_config['weighted_graph'])\\n\\n wm.generate_walks(**w_config)\\n\\n wm.fit_model(**w_config, callbacks=EpochLogger())\\n\\n n_nodes = len(set(edges.source_content_id))\\n n_transitions = n_nodes * (w_config['walk_length'] - 1) * w_config['num_walks']\\n\\n res = np.array([np.array(list(zip(x, x[1:]))).ravel() for x in wm.node2vec.walks])\\n walks = np.reshape(res, (n_transitions, 2))\\n\\n pairs = pd.DataFrame({'state1': walks[:, 0], 'state2': walks[:, 1]})\\n counts = pairs.groupby('state1')['state2'].value_counts().unstack()\\n counts = counts.replace(np.nan, 0)\\n assert pairs.shape == (n_nodes * (w_config['walk_length'] - 1) * w_config['num_walks'], 2)\\n assert counts.iloc[5][4] == 0\\n assert counts.iloc[4][5] != 0\\n assert len(set(edges['source_content_id']).union(\\n set(edges['destination_content_id']))) == len(wm.model.wv.vocab.keys())\",\n \"def count_edges(input_first, input_second, problem):\\n\\tcount = 0\\n\\tfor idx in xrange(len(input_first)):\\n\\t\\tfor index in xrange(len(input_second)):\\n\\t\\t\\tif (input_first[idx], input_second[index]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\t\\t\\telif (input_second[index], input_first[idx]) in problem:\\n\\t\\t\\t\\tcount += 1\\n\\treturn count\",\n \"def get_no_of_annotations(database, label, train_vids_all):\\n count = 0\\n for vid in train_vids_all:\\n for ann in database[vid]['annotations']:\\n if ann['label'] == label:\\n count += 1\\n return count\",\n \"def Nedges(self):\\n return len(self.edges)\",\n \"def neighbor_count(A):\\n sum2 = lambda A, B: map2(add, A, B)\\n neighbors = ((-1, -1), (-1, 0), (-1, 1),\\n (0, -1), (0, 1),\\n (1, -1), (1, 0), (1, 1))\\n return reduce(sum2,\\n map(lambda d: rotate2(A, d[0], d[1]),\\n neighbors))\",\n \"def num_links(self):\\n count=0.0\\n for cluster in self.clusters:\\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\\n numberofmembers=self.clusters[cluster].number_of_members\\n count+=numberofmembers\\n return count\",\n \"def number_of_connections(self, asn):\\n customer_count = 0\\n provider_count = 0\\n peer_count = 0\\n\\n for neighbor in nx.all_neighbors(self, asn):\\n edge_data = self.get_edge_data(asn, neighbor)\\n if edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as1\\\"] == asn:\\n customer_count += 1\\n elif edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as2\\\"] == asn:\\n provider_count += 1\\n elif edge_data[\\\"relationship\\\"] == 0:\\n peer_count += 1\\n return customer_count, provider_count, peer_count\",\n \"def clear_mappings(g, source):\\n\\n if \\\"m\\\" in g.node[source]:\\n del g.node[source][\\\"m\\\"]\\n\\n for n in g.neighbors_iter(source):\\n if \\\"m\\\" in g.node[n]:\\n del g.node[n][\\\"m\\\"]\",\n \"def count_pathologies(graph):\\n return Counter(_pathology_iterator(graph))\",\n \"def size(self):\\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))\",\n \"def num_edges(self):\\n return sum(len(v.adj) for v in self.vertices.values())\",\n \"def multi_edge():\\n from networkx.readwrite import json_graph\\n import networkx as nx\\n import autonetkit\\n # returns a house graph\\n data = {'directed': False,\\n 'graph': [],\\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 1},\\n {'_ports': {'r2': 3, 'r4': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r2': 4, 'r4': 3},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r3': 3, 'r5': 2},\\n 'raw_interfaces': {},\\n 'source': 1,\\n 'target': 4},\\n {'_ports': {'r1': 1, 'r2': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 3, 'r2': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 2, 'r3': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 4, 'r3': 4},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 5, 'r3': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r2': 2, 'r3': 2},\\n 'raw_interfaces': {},\\n 'source': 3,\\n 'target': 4}],\\n 'multigraph': True,\\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r4',\\n 'label': 'r4',\\n 'x': 675,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r5',\\n 'label': 'r5',\\n 'x': 675,\\n 'y': 500},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r1',\\n 'label': 'r1',\\n 'x': 350,\\n 'y': 400},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r2',\\n 'label': 'r2',\\n 'x': 500,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r3',\\n 'label': 'r3',\\n 'x': 500,\\n 'y': 500}]}\\n graph = json_graph.node_link_graph(data)\\n anm = autonetkit.anm.NetworkModel()\\n g_in = anm.add_overlay(\\\"input\\\")\\n g_in._replace_graph(nx.MultiGraph(graph))\\n # TODO: check if should build overlays here rather than clone in?\\n g_phy = anm[\\\"phy\\\"]\\n g_phy._replace_graph(graph)\\n return anm\",\n \"def edge_count(self):\\n total = sum(len(self._outgoing[v]) for v in self._outgoing)\\n # for undirected graphs, make sure not to double-count edges\\n return total if self.is_directed() else total // 2\",\n \"def terminals(self):\\n unique_nodes, unique_counts = np.unique(self.edges, return_counts=True)\\n return unique_nodes[ unique_counts == 1 ]\",\n \"def multiple_connections_histogram(synapses):\\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\\n return count_of_synapses\",\n \"def get_nodes_pixel_count(self):\\n sum_count = self.pixel_count\\n for i in range(8):\\n node = self.children[i]\\n if node:\\n sum_count += node.pixel_count\\n return sum_count\",\n \"def totalConnections(analyzer):\\n return model.totalConnections(analyzer)\",\n \"def ray_label_simplex(grid, simplex, thresh):\\n coords = [grid[:,x] for x in simplex]\\n dist = squareform(pdist(coords,'euclidean'))\\n adjacency = dist<thresh\\n adjacency = adjacency.astype(int) \\n graph = csr_matrix(adjacency)\\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\\n\\n return n_components\",\n \"def graph_to_input_target(graph):\\n\\n def create_feature(attr, fields):\\n return np.hstack([np.array(attr[field], dtype=float) for field in fields])\\n\\n input_node_fields = (\\\"pos\\\", \\\"start\\\", \\\"end\\\")\\n input_edge_fields = (\\\"distance\\\",)\\n target_node_fields = (\\\"solution\\\",)\\n target_edge_fields = (\\\"solution\\\",)\\n\\n input_graph = graph.copy()\\n target_graph = graph.copy()\\n\\n solution_length = 0\\n for node_index, node_feature in graph.nodes(data=True):\\n input_graph.add_node(\\n node_index, features=create_feature(node_feature, input_node_fields))\\n target_node = to_one_hot(\\n create_feature(node_feature, target_node_fields).astype(int), 2)[0]\\n target_graph.add_node(node_index, features=target_node)\\n solution_length += int(node_feature[\\\"solution\\\"])\\n solution_length /= graph.number_of_nodes()\\n\\n for receiver, sender, features in graph.edges(data=True):\\n input_graph.add_edge(\\n sender, receiver, features=create_feature(features, input_edge_fields))\\n target_edge = to_one_hot(\\n create_feature(features, target_edge_fields).astype(int), 2)[0]\\n target_graph.add_edge(sender, receiver, features=target_edge)\\n\\n input_graph.graph[\\\"features\\\"] = np.array([0.0])\\n target_graph.graph[\\\"features\\\"] = np.array([solution_length], dtype=float)\\n\\n return input_graph, target_graph\",\n \"def count_target(self):\\n tally = {}\\n for obj in self.target:\\n tally[obj] = 0\\n\\n ind = 0\\n for label in self.labelList:\\n filename = self.pathLabel + label\\n f = open(filename, 'r')\\n content = f.read().split('\\\\n')\\n for line in content:\\n items = line.split(' ')\\n if items[0] in self.target:\\n tally[items[0]] += 1\\n f.close()\\n if ind % 100 == 0:\\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\\n ind += 1\\n \\n print('[COUNT] done counting targets in dataset')\\n print(tally)\",\n \"def fill_count(nid):\\n n_edges = G.subgraph(G.neighbors(nid)).number_of_edges()\\n deg = G.degree[nid]\\n n_fill = deg*(deg-1)//2 - n_edges\\n return n_fill\",\n \"def num_nodes(g):\\n return len(g.keys())\",\n \"def num_edges(graph1: list, graph2: list):\\n check1 = 0\\n check2 = 0\\n for row, _ in enumerate(graph1):\\n for column, _ in enumerate(graph1[row]):\\n if graph1[row][column] == 1:\\n check1 += 1\\n if graph2[row][column] == 1:\\n check2 += 1\\n return check1 == check2\",\n \"def countNeighbors(oldgen, x, y):\\n temp = 1\\n\\n count = 0\\n for i in range(-1, 2):\\n for j in range(-1, 2):\\n\\n # TODO: this needs rewritin to be more understandable\\n if not (i == 0 and j == 0):\\n count += int(oldgen[(x + i + WID) % WID][(y + j + HGT) % HGT])\\n\\n for i in range(-1, 2):\\n for j in range(-1, 2):\\n temp += 1\\n\\n count -= int(oldgen[x][y])\\n\\n return count\",\n \"def edge_count(self):\\r\\n return int(sum(self.degree(node) for node in range(self.size))/2)\",\n \"def _num_conn_comp(graph):\\n\\n return nx.number_connected_components(graph)\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def _num_edges(self):\\n return int(self._edge_map[-1])\",\n \"def edge_status(g, source, target):\\n edge = source, target, g.graph['edge_key']\\n if edge in g.graph['negatives']:\\n status = 0\\n elif edge in g.graph['positives']:\\n status = 1\\n else:\\n status = int(g.has_edge(*edge)) + 2\\n return status\",\n \"def get_node_count(self) -> Iterable:\\n return self._g.V().count().toList()[0]\",\n \"def compute_num_nodes(graph):\\n return len(graph.keys()) # return the number of nodes in the graph\",\n \"def neato_graph_from_corpus( corpus, max_nodes ) :\\n\\n O, row_dois, column_dois = cites_matrix( corpus )\\n neato_cooccurrence_graph( O, column_dois )\\n return None\\n\\n \\n v = total_occurrences( O ) \\n nv = v.astype( float32 ) / v.max()\\n C = cooccurrence_matrix ( O )\\n nC = normalized_cooccurrence_matrix( O )\\n\\n # now find our cutoff!\\n # find the max number of cocites and start there\\n cocite_cutoff = C.max()\\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\\n # then reduce the number until we exceed max_nodes\\n while num_nodes < max_nodes :\\n cocite_cutoff = cocite_cutoff - 1\\n num_nodes = nodes_from_c( C[C >= cocite_cutoff] )\\n\\n if num_nodes > max_nodes :\\n cocite_cutoff = cocite_cutoff + 1\\n \\n C = C.copy()\\n C[ C < cocite_cutoff ]= 0\\n\\n graph = pydot.Dot( graph_type = 'graph' )\\n graph.set_overlap(\\\"false\\\")\\n coords = zip(*(C >= cocite_cutoff).nonzero())\\n\\n # make a dict of all nodes which are mentioned in the coords\\n nodes = {}\\n index = 1\\n for coord in set(chain.from_iterable(coords)) :\\n if not nodes.has_key( coord ) :\\n node = pydot.Node( str(coord) )\\n if v != None :\\n doi = column_dois[coord]\\n node.set_label( str(index) )\\n node.set_penwidth( nv[ coord ] )\\n node.set_fixedsize(\\\"true\\\")\\n node.set_width( 1.0 *nv[ coord ] )\\n #node.set_shape(\\\"circle\\\")\\n nodes[ coord ] = node\\n graph.add_node( node )\\n index = index + 1\\n\\n for coord in coords :\\n \\n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\\n edge.set_weight( nC[coord] )\\n edge.set_penwidth( nC[coord]*5 )\\n #edge.set_label( str(int(m[coord]) ))\\n graph.add_edge(edge)\\n\\n \\n legend = pydot.Node( \\\"legend\\\" )\\n nodelist = nodes.items()\\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\\n legend.set_label( \\\"\\\\l\\\".join([x[1].get_label()+\\\":\\\"+column_dois[x[0]] for x in nodelist])+\\\"\\\\l\\\" )\\n legend.set_shape(\\\"box\\\")\\n graph.add_node(legend)\\n\\n print graph.to_string()\\n #graph.write_dot('test.dot', prog='neato' )\\n #graph.write_png('test.png', prog='neato' )\\n #graph.write_pdf('test.pdf', prog='neato' )\",\n \"def get_annotations(graph):\\n return set(_annotation_iter_helper(graph))\",\n \"def node_size(graph):\\n adj = nx.betweenness_centrality(graph)\\n return np.array([x * 1e3 for x in adj.values()])\",\n \"def get_unused_annotations(graph):\\n return graph.defined_annotation_keywords - get_annotations(graph)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.64924645","0.61406404","0.60482","0.5913293","0.5882233","0.5866123","0.5851271","0.58161896","0.57976633","0.57823884","0.57695407","0.57527435","0.56889486","0.5676223","0.5665394","0.5659691","0.5659477","0.56017035","0.556301","0.5519132","0.5494026","0.5463144","0.54623425","0.54562557","0.5451037","0.54458684","0.54374087","0.54263175","0.54207623","0.5418176","0.5417228","0.5413756","0.5394407","0.5388614","0.53638697","0.5357805","0.53553265","0.5347532","0.53444546","0.53407776","0.533053","0.53300446","0.53263956","0.5315699","0.5310262","0.5301028","0.5301028","0.52979857","0.5297151","0.5295162","0.5287598","0.52859503","0.5282129","0.5275261","0.52675724","0.5266602","0.5263465","0.52595454","0.5257908","0.5254693","0.52444863","0.5242364","0.5223764","0.52223074","0.52180094","0.5215447","0.5211022","0.52107185","0.5207679","0.5204148","0.5203498","0.5192828","0.51867795","0.5163982","0.51636136","0.51512307","0.5146675","0.5145859","0.5142345","0.51307386","0.51217616","0.51205313","0.51176775","0.511645","0.51162034","0.51159513","0.51136464","0.51111764","0.50975287","0.5095194","0.5094819","0.5093058","0.5092515","0.50862825","0.50854754","0.5078303","0.5067692","0.50639117","0.50467914","0.5043648"],"string":"[\n \"0.64924645\",\n \"0.61406404\",\n \"0.60482\",\n \"0.5913293\",\n \"0.5882233\",\n \"0.5866123\",\n \"0.5851271\",\n \"0.58161896\",\n \"0.57976633\",\n \"0.57823884\",\n \"0.57695407\",\n \"0.57527435\",\n \"0.56889486\",\n \"0.5676223\",\n \"0.5665394\",\n \"0.5659691\",\n \"0.5659477\",\n \"0.56017035\",\n \"0.556301\",\n \"0.5519132\",\n \"0.5494026\",\n \"0.5463144\",\n \"0.54623425\",\n \"0.54562557\",\n \"0.5451037\",\n \"0.54458684\",\n \"0.54374087\",\n \"0.54263175\",\n \"0.54207623\",\n \"0.5418176\",\n \"0.5417228\",\n \"0.5413756\",\n \"0.5394407\",\n \"0.5388614\",\n \"0.53638697\",\n \"0.5357805\",\n \"0.53553265\",\n \"0.5347532\",\n \"0.53444546\",\n \"0.53407776\",\n \"0.533053\",\n \"0.53300446\",\n \"0.53263956\",\n \"0.5315699\",\n \"0.5310262\",\n \"0.5301028\",\n \"0.5301028\",\n \"0.52979857\",\n \"0.5297151\",\n \"0.5295162\",\n \"0.5287598\",\n \"0.52859503\",\n \"0.5282129\",\n \"0.5275261\",\n \"0.52675724\",\n \"0.5266602\",\n \"0.5263465\",\n \"0.52595454\",\n \"0.5257908\",\n \"0.5254693\",\n \"0.52444863\",\n \"0.5242364\",\n \"0.5223764\",\n \"0.52223074\",\n \"0.52180094\",\n \"0.5215447\",\n \"0.5211022\",\n \"0.52107185\",\n \"0.5207679\",\n \"0.5204148\",\n \"0.5203498\",\n \"0.5192828\",\n \"0.51867795\",\n \"0.5163982\",\n \"0.51636136\",\n \"0.51512307\",\n \"0.5146675\",\n \"0.5145859\",\n \"0.5142345\",\n \"0.51307386\",\n \"0.51217616\",\n \"0.51205313\",\n \"0.51176775\",\n \"0.511645\",\n \"0.51162034\",\n \"0.51159513\",\n \"0.51136464\",\n \"0.51111764\",\n \"0.50975287\",\n \"0.5095194\",\n \"0.5094819\",\n \"0.5093058\",\n \"0.5092515\",\n \"0.50862825\",\n \"0.50854754\",\n \"0.5078303\",\n \"0.5067692\",\n \"0.50639117\",\n \"0.50467914\",\n \"0.5043648\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7213139"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20167,"cells":{"query":{"kind":"string","value":"Iterates over unique nodenode pairs in the graph"},"document":{"kind":"string","value":"def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target","def iter_nodes(self):","def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))","def nodes(self):\n for node_set in self.itervalues():\n for node in node_set:\n yield node","def iter_node(self,i):\n nd = self.nodes[i]\n for kn in nd.get_close():\n # for kn in nd.get_known():\n # for kn in nd.neighbours:\n kn_node = self.nodes[kn.lindex]\n nd.add_known_nodes(kn.path_len,kn_node.get_close())","def nodes_iter(self) -> Generator:\n for n in self.graph.nodes(data=True):\n yield n","def _get_common_neighbour_node_pairs(self):\n node_pairs = []\n for node1 in self.graph.nodes():\n for node2 in self.graph.nodes():\n if node1 != node2:\n neighbour_count = self.neighbour_counts[(node1, node2)]\n if neighbour_count >= 1:\n node_pairs.append((node1, node2))\n return node_pairs","def mut_space(graph: nx.Graph) -> t.Iterator[t.Tuple[int, t.List[str]]]:\n genes = get_attr(graph, 'gene')\n xs = sorted(chain.from_iterable(((g.P1, g.A1), (g.P2, g.A2)) for g in genes))\n return ((g, sorted(set(x[1] for x in gg))) for g, gg in groupby(xs, key=op.itemgetter(0)))","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def neighbors_iter(node, topology):\n return topology[node]","def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for neighbour in self.__graph_dict[node]:\n # Since all edges go both ways, we need only return one of them.\n if {neighbour, node} not in edges:\n edges.append({node, neighbour})\n yield (node, neighbour)","def likely_pairs(self, k=2):\n for a in self.G.nodes():\n if not self.eligible_node(a):\n continue\n for b in neighbourhood(self.G, a, k):\n if not self.eligible_node(b):\n continue\n yield (a, b)","def connect_all(graph, nodeset):\n for element in nodeset:\n graph.add_node(element)\n for element1 in nodeset:\n for element2 in nodeset:\n if not element1 == element2:\n graph.add_edge(element1, element2)\n return graph","def nodes_iter(topology):\n return topology.nodes_iter()","def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v","def _create_node_iterator(self) -> Iterator[GraphNode]:\n return\n yield","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def nodes(self):\n\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))","def _find_paired_nodes(self, graph):\n paired_list = []\n for line in nx.generate_edgelist(graph):\n if ('basepair' in line):\n if not (int(line.split(' ')[0]) in paired_list):\n paired_list.append(int(line.split(' ')[0]))\n if not (int(line.split(' ')[1]) in paired_list):\n paired_list.append(int(line.split(' ')[1]))\n return paired_list","def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\n if nbunch is None:\n nbunch = G\n else:\n nbunch = set(nbunch)\n\n directed = G.is_directed()\n if directed:\n iter_func = itertools.permutations\n else:\n iter_func = itertools.combinations\n\n all_pairs = {n: {} for n in nbunch}\n\n for u, v in iter_func(nbunch, 2):\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\n all_pairs[u][v] = k\n if not directed:\n all_pairs[v][u] = k\n\n return all_pairs","def differentNodesForNode(ntupleSet,nodeList,verbose=False):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n nodesPerNode[a] = set(v)\n \n return nodesPerNode","def iter_all(self):\n for i in range(self.num_nodes):\n self.iter_node(i)","def fdupes(g, node_prefix='_qh/',edge_type='qhash'):\n build_index_on_node_attr(g, 'qhash', 'f', node_prefix=node_prefix, expand=True)\n paths = g.node_labels\n print '\\n'.join(sorted(str(s) for s in paths.items()))\n for k in paths:\n if k:\n edge = g.edge[k]\n if len(edge) > 1:\n for path in edge:\n print paths.get(path) # , g.node[path]\n print ''","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n ntuple.sort()\n joinedTuple = \"\".join(ntuple)\n for nodeInTuple in ntuple:\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\n \n for a,v in ntuplesPerNode.iteritems():\n ntuplesPerNode[a] = set(v)\n \n return ntuplesPerNode","def iter_links(self):\n for site in self.iter_sites():\n for u in range(self.dim):\n yield tuple(list(site) + [u])","def neighbours(assignment): \n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\n new_assign = list(assignment)\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\n yield tuple(new_assign)","def get_connected_nodes(self, node):\n assert node in self.nodes, \"No node \"+str(node)+\" in graph \"+str(self)\n result = [x.node2 for x in self.edges if x.node1 == node]\n result += [x.node1 for x in self.edges if x.node2 == node]\n return sorted(result)","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def edges_iter(self) -> Generator:\n for u, v, k, data in self.graph.edges(keys=True, data=True):\n yield u, v, k, data","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def traverse(self, data=True):\n nodes = sorted(self.graph.nodes(), key=lambda x: key_to_numeric(x))\n for node in nodes:\n yield (node, self.graph.node[node]) if data else node","def _pair_based_graph_cut(self, graph):\n for node in self._find_paired_nodes(graph):\n graph.remove_node(node)\n return","def get_contradictory_pairs(graph):\n for u, v in _iter_pairs(graph):\n if pair_has_contradiction(graph, u, v):\n yield u, v","def connect_nodes(self):\n for src_id, trg_id in itertools.product(self.selected_nodes, repeat=2):\n if src_id != trg_id:\n app.edges[src_id].add(trg_id)\n self.mark_as_unsaved()\n self.update()","def directed(self):\n seen = {}\n for up, down in self:\n if (up is None) or (down is None):\n continue #omit unpaired bases\n if up > down:\n up, down = down, up\n seen[(up, down)] = True\n result = seen.keys()\n return Pairs(result)","def iter_node_map(self):\n return self.d_inv.keys()","def _pathology_iterator(graph):\n for u, v in _iter_pairs(graph):\n if graph.node[u][FUNCTION] == PATHOLOGY:\n yield u\n if graph.node[v][FUNCTION] == PATHOLOGY:\n yield v","def matching_graph(n):\r\n k_n = nx.complete_graph(n)\r\n G = nx.Graph()\r\n for i in k_n.edges():\r\n G.add_node(i)\r\n w = []\r\n for i in k_n.edges():\r\n for j in k_n.edges():\r\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \r\n w.append((i,j))\r\n G.add_edge(i,j)\r\n return G","def indirect(stack):\n g = nx.Graph(stack)\n for group in nx.connected_components(g):\n yield from map(frozenset, combinations(group, 2))","def topological_nodes_generator(graph, reverse=...):\n ...","def _connect_neighbours(self):\n for prev in self.unvisited:\n for next in self.unvisited:\n if (next[0] == prev[0] and next[1] == prev[1] + 1) or (next[0] == prev[0] + 1 and next[1] == prev[1]):\n self.graph.addEdge((prev, next))\n self.visited.add(prev)\n self.visited.add(next)\n if self._find_intersection():\n self.intersection.append(prev)\n self.intersection.append(next)","def neighbours(self, node: Node) -> Iterable[Node]:\n if node is None:\n return None\n for neighbour in self.__graph_dict[node]:\n yield neighbour","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def iterate_nodes(\n self,\n keys: istr = None,\n terms: istr = None,\n prefixes: istr = None,\n labels: istr = None,\n ) -> Iterable[Node]:","def enumerate_links_around_node(self, node):\n\n l0 = self.node_link[node]\n l = l0\n edges = []\n traversing = True\n while traversing:\n edges.append(l)\n v = l[0]\n if v == node:\n l = self.pred_right[l]\n else:\n l = self.pred_left[l]\n if l0 == l:\n traversing = False\n if l0[1] == l[0] and l0[0] == l[1]:\n traversing = False\n #print v, l\n #raw_input('here')\n return edges","def add_all_edges(self):\n for n1 in self.vertices():\n for n2 in self.vertices():\n if n1 != n2:\n self.add_edge((n1, n2))","def vertex_iterator(self):\n for X in self.fe.L:\n for x in self.K.unit_group:\n yield (X, x)","def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\n\n n = len(aggr1)\n \n test_pairs = []\n for i in range(0, n):\n for j in range(0, n):\n if (aggr1[i] in table and aggr2[j] in table \n and (aggr1[i], aggr2[j]) in G.edges()\n ):\n test_pairs.append((aggr1[i], aggr2[j]))\n \n return test_pairs","def graph():\n\n graph = {'A': ['B', 'C'],\n 'B': ['C', 'D'],\n 'C': ['D'],\n 'D': ['C'],\n 'E': ['F'],\n 'F': ['C']}\n\n def generate_edges(graph):\n \"\"\" Convert the dict representation of a graph into a list one\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\n \"\"\"\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges\n\n a = generate_edges(graph=graph)\n print(a)","def run_adding_edges(self):\n indices = np.where(self.X==0)\n idx=[]\n for i in range(len(indices[0])):\n idx.append((indices[0][i],indices[1][i]))\n idx = np.array(idx)\n return self.node_equivalent(idx)","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({neighbour, vertex})\n return edges","def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\n n = len(nodes)\n return [(u, nodes[j % n])\n for i, u in enumerate(nodes)\n for j in range(i + 1, i + 1 + k // 2)]","def cooccuranceBlock(ntupleSet,nodeList):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n differentNodes = set(v).difference(set([a]))\n NumberdifferentNodes = len(differentNodes) \n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\n \n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n edges.append({vertex, neighbour})\n return edges","def graph_nodes(dependencies):\n\n return set.union(set(dependencies), *list(dependencies.values()))","def graph_generation(nodes: np.ndarray, edges: np.ndarray):\n result_nodes = []\n result_edges = []\n\n last_index = nodes[-1, 0]\n\n done = False\n # print(nodes)\n for p in range(nodes.shape[0]):\n for q in range(nodes.shape[0]):\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\n nodes[q, nodes.shape[1] - 2]:\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\n np.append(nodes[q, nodes.shape[1] - 1],\n np.append(nodes[p, 0],\n nodes[q, 0]))))\n if not done:\n result_nodes = [tmp_node]\n done = True\n else:\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\n\n result_nodes = result_nodes[np.argsort(\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\n\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\n # print(result_nodes)\n\n done = False\n for e in range(edges.shape[0]):\n for f in range(edges.shape[0]):\n for p in range(result_nodes.shape[0]):\n for q in range(result_nodes.shape[0]):\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\n result_nodes[p, -1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\n result_nodes[p, -2] == result_nodes[q, -2]):\n if not done:\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\n done = True\n else:\n result_edges = np.concatenate(\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\n # print(edges)\n\n # print(result_edges)\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\n # print(unique_result_edges)\n final_edges = []\n for k in range(len(unique_result_edges)):\n for j in range(result_edges.shape[0]):\n if str(result_edges[j]) == unique_result_edges[k]:\n if k == 0:\n final_edges = result_edges[j]\n break\n else:\n final_edges = np.concatenate((final_edges, result_edges[j]))\n break\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\n # print(final_edges.shape[0])\n done = False\n edge_to_remove = []\n for j in range(final_edges.shape[0]):\n for k in range(j + 1, final_edges.shape[0]):\n if final_edges[j, 1] == final_edges[k, 0]:\n if not done:\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\n done = True\n else:\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\n # print(edge_to_remove)\n\n idx_to_remove = []\n done = False\n for j in range(edge_to_remove.shape[0]):\n for k in range(final_edges.shape[0]):\n if list(edge_to_remove[j]) == list(final_edges[k]):\n if not done:\n idx_to_remove = k\n done = True\n else:\n idx_to_remove = np.append(idx_to_remove, k)\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\n # print(final_edges)\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\n # print(result_nodes)\n return result_nodes, final_edges","def merge_duplicate_nodes(self):\n merges={}\n xys={}\n for n in self.valid_node_iter():\n k=tuple(self.nodes['x'][n])\n if k in xys:\n merges[n]=xys[k]\n self.merge_nodes(xys[k],n)\n else:\n xys[k]=n\n return merges","def pairs_of_vertices(self):\n pairs_of_vertices = []\n for vertice in self.list_of_vertices:\n for edge in vertice.edges_list:\n if non_oriented:\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n if not non_oriented:\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n return pairs_of_vertices","def make_complete_graph(num_nodes):\r\n result = {}\r\n for idx in range(0,num_nodes):\r\n result[idx] = set([])\r\n for jdx in range(0,num_nodes):\r\n if (idx!=jdx):\r\n result[idx].add(jdx)\r\n return result","def get_node_pairs_from_path(path):\n\n path = path[:-1]\n pairs = []\n for i in range(len(path)):\n center_node = path[i]\n for j in range(max(i - config.window_size, 0), min(i + config.window_size + 1, len(path))):\n if i == j:\n continue\n node = path[j]\n pairs.append([center_node, node])\n return pairs","def DFS(G: List, i: int, U: List) -> List:\n node = G[i]\n node.visited = True\n U.remove(i)\n for adj_node in node.adjacent:\n if not adj_node.visited:\n DFS(G, adj_node.value, U)\n return [G, U]","def visitEdges(self) -> None:\n\n for node in self.nodesMap_.values():\n for nodeInput in node.get_inputs():\n i = nodeInput[0]\n if i.get_name() not in self.nodesMap_:\n print(i.get_kind_name(), i.get_name())\n edgeStr = self.get_unique_vertex_name(i) + \":Outputs -> \"\n edgeStr += self.get_unique_vertex_name(node) + \":Inputs\"\n self.edges_.append(edgeStr)","def find_conflicts(graph):\n for node in graph:\n for neighbour in node.neighbours:\n for n in neighbour.neighbours:\n if n is node:\n continue\n _log.info(\"Nodes %s and %s are in conflict.\" % (node, n))\n node.add_conflict_with_node(n)\n n.add_conflict_with_node(node)","def vertices(self):\n \n yielded = set()\n \n # Iterate over every tuple of edges, e.g. ..., (1, 2), (4, 3), ...\n for vertices in self.edges():\n # Iterate over every vertex in the tuple, e.g. ..., 1, 2, 4, 3, ...\n for vertex in vertices:\n # Yield if it has not been yielded already\n if vertex not in yielded:\n yield vertex","def iter_node(self):\n return self.d.keys()","def junctions(self):\n for node_name in self._junctions:\n yield node_name, self._data[node_name]","def iter_nodes(self, fields=None, **kwargs):\n columns = ['uuid', 'driver'] + list(fields or ())\n node_list = self.dbapi.get_nodeinfo_list(columns=columns, **kwargs)\n for result in node_list:\n if self._mapped_to_this_conductor(*result[:2]):\n yield result","def nodes(self):\n nodes = []\n for key, val in self._graph.items():\n nodes.append(key)\n nodes.extend([v for v in val.keys() if v not in nodes])\n return set(nodes)","def __iter__ (self, data=False):\n return self.network.nodes_iter(data=data)","def node_names(self):\n\n for node_name in self.nodes.keys():\n\n yield node_name","def _create_connections(self):\n self.predecessors = {}\n self.successors = {}\n for nd in self.nodes:\n self.predecessors[nd.name] = []\n self.successors[nd.name] = []\n\n for (nd_out, nd_in) in self.edges:\n self.predecessors[nd_in.name].append(nd_out)\n self.successors[nd_out.name].append(nd_in)","def nodes_in_triangle(G, n):\n triangle_nodes = set([n])\n \n # Iterate over all possible triangle relationship combinations\n for n1, n2 in combinations(G.neighbors(n), 2):\n \n # Check if n1 and n2 have an edge between them\n if G.has_edge(n1, n2):\n \n # Add n1 to triangle_nodes\n triangle_nodes.add(n1)\n \n # Add n2 to triangle_nodes\n triangle_nodes.add(n2)\n \n return triangle_nodes","def generate_edges(graph):\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges","def gen_graph(self):","def get_all_vertices(self):\r\n for vertex in self.__neighbours.keys():\r\n yield vertex","def test_same_node_is_reachable(self):\n # G is an arbitrary tournament on ten nodes.\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\n assert_true(all(is_reachable(G, v, v) for v in G))","def getLinkList(self, graph_dict):\n link_list = []\n for vertex in graph_dict:\n for neighbour in graph_dict[vertex]:\n if {neighbour, vertex} not in link_list:\n link_list.append({vertex, neighbour})\n link_list = [x for x in link_list if len(x) > 1]\n return link_list","def __iter__(self) -> Iterable[Node]:","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def getPairList(nodeDict):\n\n\tpairList = []\n\n\tprint \"\\tGetting list of all node pairs...\"\n\n\tfor key in nodeDict.keys():\n\t\tprint \"\\t\\tLooking at node named '%s'...\" % key\n\t\ttheNode = nodeDict[key]\n\t\tconnectionsList = theNode[2]\n\t\tif (connectionsList == None) or (connectionsList == []):\n\t\t\t# No connections, do nothing\n\t\t\tprint \"\\t\\t\\tNode has no connections.\"\n\t\t\tpass\n\t\telse:\n\t\t\tfor connection in connectionsList:\n\t\t\t\tif (key < connection):\n\t\t\t\t\ttheTuple = (key, connection)\n\t\t\t\telse:\n\t\t\t\t\ttheTuple = (connection, key)\n\t\t\t\tif pairList.count(theTuple) == 0:\n\t\t\t\t\tprint \"\\t\\t\\tConection between '%s' and '%s'.\" % theTuple\n\t\t\t\t\tpairList.append(theTuple)\n\t\t\t\telse:\n\t\t\t\t\tprint \"\\t\\t\\tConection between '%s' and '%s' skipped. Dupe.\" % theTuple\n\n\tprint \"\\tGot list of all node pairs (%d of 'em), sorting it...\" % (len(pairList))\n\n\tpairList.sort()\n\n\tprint \"\\tNode pair list sorted.\"\n\n\treturn pairList","def set_connection_between_nodes(self):\n\n for i, node in enumerate(self.list_empty_nodes):\n line = node.labyrinth_position[0]\n column = node.labyrinth_position[1]\n\n for j in range(i+1, len(self.list_empty_nodes)):\n line_j = self.list_empty_nodes[j].labyrinth_position[0]\n column_j = self.list_empty_nodes[j].labyrinth_position[1]\n \n if i != j and ((line == line_j and column == column_j - 1) \\\n or (line == line_j and column == column_j + 1) \\\n or (column == column_j and line == line_j - 1) \\\n or (column == column_j and line == line_j + 1)) \\\n and (not node in self.list_empty_nodes[j].connected_to) \\\n and (not self.list_empty_nodes[j] in node.connected_to):\n node.connected_to.append(self.list_empty_nodes[j])\n self.list_empty_nodes[j].connected_to.append(node)","def neighbours(self):\n seen = set()\n return [l.other(self) for l in self.dovetails \\\n if id(l) not in seen and not seen.add(id(l))]","def get_node_neighbors(\n self, u: Hashable, include_metadata: bool = False\n ) -> Generator:\n if include_metadata:\n return {\n e[\"target\"]: _node_to_metadata(e[\"properties\"])\n for e in (\n self._g.V()\n .has(ID, u)\n .outE()\n .project(\"target\", \"source\", \"properties\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .by(__.valueMap(True))\n .toList()\n )\n }\n return self._g.V().has(ID, u).out().values(ID).toList()","def graphs_iso(n):\n assert n >= 0\n for g in unique_iso(graphs(n)):\n yield g","def serialize_nx_node_to_triples(g, key, node=None):\n\n node = node or g and g.node.get(key) # <curie/key> # ... precis\n\n yield (key, 'a', node.get('type')) # <> a <type>\n\n for attr,value in node.items():\n yield (key, attr, value)\n\n # MultiDiGraph\n for edge in g.edge.get(key):\n # multivalue edges\n # <> linkTo _:ReifiedEdge\n\n # = BNode(), UUID\n # = edge_url\n s = '#e/'.join((key,uuid,))\n yield (s, 'a', 'edgetype')\n yield (s, 'linksFrom', key)\n yield (s, 'linksTo', edge)\n\n for attr, value in edge.items():\n yield (s, attr, edge.get(attr))\n # _:ReifiedEdge attr[n] value[n]","def find_selfloop_nodes(G):\n nodes_in_selfloops = []\n\n # Iterate over all the edges of G\n for u, v in G.edges:\n if u == v: # Check if node u and node v are the same\n nodes_in_selfloops.append(u) # Append node u to nodes_in_selfloops\n return nodes_in_selfloops","def basepairs(graph = None):\n\tbasepair_list = []\n\tfor line in nx.generate_edgelist(graph):\n\t\tif ('basepair' in line):\n\t\t\tx = int(line.split(' ')[0])\n\t\t\ty = int(line.split(' ')[1])\n\t\t\tif not (((x,y) in basepair_list) or ((y,x) in basepair_list)):\n\t\t\t\tbasepair_list.append((x,y))\n\treturn basepair_list","def allReachable(g, n):\n nodeList = []\n \n keysList = []\n\n for key in g.keys():\n keysList.append(key)\n \n for i in keysList:\n if findPath(g, n, i) != None:\n nodeList.append(i)\n \n nodeList.sort()\n nodeList.remove(n)\n \n return nodeList","def graphs_conn_iso(n):\n def graphs_conn_helper(n):\n for oldg in graphs_conn_iso(n-1):\n for s in powerset(range(n-1)):\n if s == ():\n continue\n g = oldg + [list(s)]\n for v in s:\n g[v] = g[v] + [n-1]\n # NOT g[v] += ... or g[v].append(...)\n # to avoid changing items in oldg\n yield g\n\n assert n >= 0\n if n >= 3:\n for g in unique_iso(graphs_conn_helper(n)):\n yield g\n elif n == 2:\n yield [ [1], [0] ]\n elif n == 1:\n yield [ [] ]\n else: # n == 0\n yield []","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def graph_has_self_loops(edges):\n\n for a, b in edges:\n if a == b:\n return True\n\n return False","def remove_stems(graph = None):\n\tfor x,y in basepairs(graph = graph):\n\t\tgraph.remove_node(x)\n\t\tgraph.remove_node(y)","def clean_edges(self):\n for from_node in self.all_nodes():\n for to_node in self.all_nodes():\n if from_node == to_node:\n continue\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\n if len(dup) > 1:\n for d in dup[1:]:\n self.edges.remove(d)","def __iter__(self) -> Iterable[\"AbstractLane\"]:\n for origin in self.graph:\n for destination in self.graph[origin]:\n for index, lane in self.graph[origin][destination].items():\n yield lane","def get_pairs(self):\n self.get_locations()\n self.choices = {}\n for host, pathogens in self.locations.iteritems():\n if len(pathogens) > 1:\n for pair in combinations(pathogens, 2):\n self.choices.update({pair: host}) # pairs of pathogens in same host","def graph(self):\n ...","def to_undirected_graph(self):\n visited = set() \n G = Graph.Graph()\n \n for node in self.node_set:\n \n if node not in visited:\n visited.add(node)\n for i in self.suffix[node]:\n G.add_edge(node, i)\n \n return G"],"string":"[\n \"def iteredges(self):\\n for source, targets in self.successors.items():\\n for target in targets:\\n yield source, target\",\n \"def iter_nodes(self):\",\n \"def all_pairs(self):\\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))\",\n \"def nodes(self):\\n for node_set in self.itervalues():\\n for node in node_set:\\n yield node\",\n \"def iter_node(self,i):\\n nd = self.nodes[i]\\n for kn in nd.get_close():\\n # for kn in nd.get_known():\\n # for kn in nd.neighbours:\\n kn_node = self.nodes[kn.lindex]\\n nd.add_known_nodes(kn.path_len,kn_node.get_close())\",\n \"def nodes_iter(self) -> Generator:\\n for n in self.graph.nodes(data=True):\\n yield n\",\n \"def _get_common_neighbour_node_pairs(self):\\n node_pairs = []\\n for node1 in self.graph.nodes():\\n for node2 in self.graph.nodes():\\n if node1 != node2:\\n neighbour_count = self.neighbour_counts[(node1, node2)]\\n if neighbour_count >= 1:\\n node_pairs.append((node1, node2))\\n return node_pairs\",\n \"def mut_space(graph: nx.Graph) -> t.Iterator[t.Tuple[int, t.List[str]]]:\\n genes = get_attr(graph, 'gene')\\n xs = sorted(chain.from_iterable(((g.P1, g.A1), (g.P2, g.A2)) for g in genes))\\n return ((g, sorted(set(x[1] for x in gg))) for g, gg in groupby(xs, key=op.itemgetter(0)))\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def neighbors_iter(node, topology):\\n return topology[node]\",\n \"def edges(self) -> Iterable[Tuple[Node]]:\\n edges = []\\n for node in self.__graph_dict.keys():\\n for neighbour in self.__graph_dict[node]:\\n # Since all edges go both ways, we need only return one of them.\\n if {neighbour, node} not in edges:\\n edges.append({node, neighbour})\\n yield (node, neighbour)\",\n \"def likely_pairs(self, k=2):\\n for a in self.G.nodes():\\n if not self.eligible_node(a):\\n continue\\n for b in neighbourhood(self.G, a, k):\\n if not self.eligible_node(b):\\n continue\\n yield (a, b)\",\n \"def connect_all(graph, nodeset):\\n for element in nodeset:\\n graph.add_node(element)\\n for element1 in nodeset:\\n for element2 in nodeset:\\n if not element1 == element2:\\n graph.add_edge(element1, element2)\\n return graph\",\n \"def nodes_iter(topology):\\n return topology.nodes_iter()\",\n \"def get_inconsistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def _create_node_iterator(self) -> Iterator[GraphNode]:\\n return\\n yield\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def nodes(self):\\n\\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))\",\n \"def _find_paired_nodes(self, graph):\\n paired_list = []\\n for line in nx.generate_edgelist(graph):\\n if ('basepair' in line):\\n if not (int(line.split(' ')[0]) in paired_list):\\n paired_list.append(int(line.split(' ')[0]))\\n if not (int(line.split(' ')[1]) in paired_list):\\n paired_list.append(int(line.split(' ')[1]))\\n return paired_list\",\n \"def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\\n if nbunch is None:\\n nbunch = G\\n else:\\n nbunch = set(nbunch)\\n\\n directed = G.is_directed()\\n if directed:\\n iter_func = itertools.permutations\\n else:\\n iter_func = itertools.combinations\\n\\n all_pairs = {n: {} for n in nbunch}\\n\\n for u, v in iter_func(nbunch, 2):\\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\\n all_pairs[u][v] = k\\n if not directed:\\n all_pairs[v][u] = k\\n\\n return all_pairs\",\n \"def differentNodesForNode(ntupleSet,nodeList,verbose=False):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n nodesPerNode[a] = set(v)\\n \\n return nodesPerNode\",\n \"def iter_all(self):\\n for i in range(self.num_nodes):\\n self.iter_node(i)\",\n \"def fdupes(g, node_prefix='_qh/',edge_type='qhash'):\\n build_index_on_node_attr(g, 'qhash', 'f', node_prefix=node_prefix, expand=True)\\n paths = g.node_labels\\n print '\\\\n'.join(sorted(str(s) for s in paths.items()))\\n for k in paths:\\n if k:\\n edge = g.edge[k]\\n if len(edge) > 1:\\n for path in edge:\\n print paths.get(path) # , g.node[path]\\n print ''\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n ntuple.sort()\\n joinedTuple = \\\"\\\".join(ntuple)\\n for nodeInTuple in ntuple:\\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\\n \\n for a,v in ntuplesPerNode.iteritems():\\n ntuplesPerNode[a] = set(v)\\n \\n return ntuplesPerNode\",\n \"def iter_links(self):\\n for site in self.iter_sites():\\n for u in range(self.dim):\\n yield tuple(list(site) + [u])\",\n \"def neighbours(assignment): \\n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\\n new_assign = list(assignment)\\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\\n yield tuple(new_assign)\",\n \"def get_connected_nodes(self, node):\\n assert node in self.nodes, \\\"No node \\\"+str(node)+\\\" in graph \\\"+str(self)\\n result = [x.node2 for x in self.edges if x.node1 == node]\\n result += [x.node1 for x in self.edges if x.node2 == node]\\n return sorted(result)\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def edges_iter(self) -> Generator:\\n for u, v, k, data in self.graph.edges(keys=True, data=True):\\n yield u, v, k, data\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def traverse(self, data=True):\\n nodes = sorted(self.graph.nodes(), key=lambda x: key_to_numeric(x))\\n for node in nodes:\\n yield (node, self.graph.node[node]) if data else node\",\n \"def _pair_based_graph_cut(self, graph):\\n for node in self._find_paired_nodes(graph):\\n graph.remove_node(node)\\n return\",\n \"def get_contradictory_pairs(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_has_contradiction(graph, u, v):\\n yield u, v\",\n \"def connect_nodes(self):\\n for src_id, trg_id in itertools.product(self.selected_nodes, repeat=2):\\n if src_id != trg_id:\\n app.edges[src_id].add(trg_id)\\n self.mark_as_unsaved()\\n self.update()\",\n \"def directed(self):\\n seen = {}\\n for up, down in self:\\n if (up is None) or (down is None):\\n continue #omit unpaired bases\\n if up > down:\\n up, down = down, up\\n seen[(up, down)] = True\\n result = seen.keys()\\n return Pairs(result)\",\n \"def iter_node_map(self):\\n return self.d_inv.keys()\",\n \"def _pathology_iterator(graph):\\n for u, v in _iter_pairs(graph):\\n if graph.node[u][FUNCTION] == PATHOLOGY:\\n yield u\\n if graph.node[v][FUNCTION] == PATHOLOGY:\\n yield v\",\n \"def matching_graph(n):\\r\\n k_n = nx.complete_graph(n)\\r\\n G = nx.Graph()\\r\\n for i in k_n.edges():\\r\\n G.add_node(i)\\r\\n w = []\\r\\n for i in k_n.edges():\\r\\n for j in k_n.edges():\\r\\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \\r\\n w.append((i,j))\\r\\n G.add_edge(i,j)\\r\\n return G\",\n \"def indirect(stack):\\n g = nx.Graph(stack)\\n for group in nx.connected_components(g):\\n yield from map(frozenset, combinations(group, 2))\",\n \"def topological_nodes_generator(graph, reverse=...):\\n ...\",\n \"def _connect_neighbours(self):\\n for prev in self.unvisited:\\n for next in self.unvisited:\\n if (next[0] == prev[0] and next[1] == prev[1] + 1) or (next[0] == prev[0] + 1 and next[1] == prev[1]):\\n self.graph.addEdge((prev, next))\\n self.visited.add(prev)\\n self.visited.add(next)\\n if self._find_intersection():\\n self.intersection.append(prev)\\n self.intersection.append(next)\",\n \"def neighbours(self, node: Node) -> Iterable[Node]:\\n if node is None:\\n return None\\n for neighbour in self.__graph_dict[node]:\\n yield neighbour\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def iterate_nodes(\\n self,\\n keys: istr = None,\\n terms: istr = None,\\n prefixes: istr = None,\\n labels: istr = None,\\n ) -> Iterable[Node]:\",\n \"def enumerate_links_around_node(self, node):\\n\\n l0 = self.node_link[node]\\n l = l0\\n edges = []\\n traversing = True\\n while traversing:\\n edges.append(l)\\n v = l[0]\\n if v == node:\\n l = self.pred_right[l]\\n else:\\n l = self.pred_left[l]\\n if l0 == l:\\n traversing = False\\n if l0[1] == l[0] and l0[0] == l[1]:\\n traversing = False\\n #print v, l\\n #raw_input('here')\\n return edges\",\n \"def add_all_edges(self):\\n for n1 in self.vertices():\\n for n2 in self.vertices():\\n if n1 != n2:\\n self.add_edge((n1, n2))\",\n \"def vertex_iterator(self):\\n for X in self.fe.L:\\n for x in self.K.unit_group:\\n yield (X, x)\",\n \"def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\\n\\n n = len(aggr1)\\n \\n test_pairs = []\\n for i in range(0, n):\\n for j in range(0, n):\\n if (aggr1[i] in table and aggr2[j] in table \\n and (aggr1[i], aggr2[j]) in G.edges()\\n ):\\n test_pairs.append((aggr1[i], aggr2[j]))\\n \\n return test_pairs\",\n \"def graph():\\n\\n graph = {'A': ['B', 'C'],\\n 'B': ['C', 'D'],\\n 'C': ['D'],\\n 'D': ['C'],\\n 'E': ['F'],\\n 'F': ['C']}\\n\\n def generate_edges(graph):\\n \\\"\\\"\\\" Convert the dict representation of a graph into a list one\\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\\n \\\"\\\"\\\"\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\\n\\n a = generate_edges(graph=graph)\\n print(a)\",\n \"def run_adding_edges(self):\\n indices = np.where(self.X==0)\\n idx=[]\\n for i in range(len(indices[0])):\\n idx.append((indices[0][i],indices[1][i]))\\n idx = np.array(idx)\\n return self.node_equivalent(idx)\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({neighbour, vertex})\\n return edges\",\n \"def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\\n n = len(nodes)\\n return [(u, nodes[j % n])\\n for i, u in enumerate(nodes)\\n for j in range(i + 1, i + 1 + k // 2)]\",\n \"def cooccuranceBlock(ntupleSet,nodeList):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n differentNodes = set(v).difference(set([a]))\\n NumberdifferentNodes = len(differentNodes) \\n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\\n \\n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def graph_nodes(dependencies):\\n\\n return set.union(set(dependencies), *list(dependencies.values()))\",\n \"def graph_generation(nodes: np.ndarray, edges: np.ndarray):\\n result_nodes = []\\n result_edges = []\\n\\n last_index = nodes[-1, 0]\\n\\n done = False\\n # print(nodes)\\n for p in range(nodes.shape[0]):\\n for q in range(nodes.shape[0]):\\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\\\\n nodes[q, nodes.shape[1] - 2]:\\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\\n np.append(nodes[q, nodes.shape[1] - 1],\\n np.append(nodes[p, 0],\\n nodes[q, 0]))))\\n if not done:\\n result_nodes = [tmp_node]\\n done = True\\n else:\\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\\n\\n result_nodes = result_nodes[np.argsort(\\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\\n\\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\\n # print(result_nodes)\\n\\n done = False\\n for e in range(edges.shape[0]):\\n for f in range(edges.shape[0]):\\n for p in range(result_nodes.shape[0]):\\n for q in range(result_nodes.shape[0]):\\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\\n result_nodes[p, -1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\\n result_nodes[p, -2] == result_nodes[q, -2]):\\n if not done:\\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\\n done = True\\n else:\\n result_edges = np.concatenate(\\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\\n # print(edges)\\n\\n # print(result_edges)\\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\\n # print(unique_result_edges)\\n final_edges = []\\n for k in range(len(unique_result_edges)):\\n for j in range(result_edges.shape[0]):\\n if str(result_edges[j]) == unique_result_edges[k]:\\n if k == 0:\\n final_edges = result_edges[j]\\n break\\n else:\\n final_edges = np.concatenate((final_edges, result_edges[j]))\\n break\\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\\n # print(final_edges.shape[0])\\n done = False\\n edge_to_remove = []\\n for j in range(final_edges.shape[0]):\\n for k in range(j + 1, final_edges.shape[0]):\\n if final_edges[j, 1] == final_edges[k, 0]:\\n if not done:\\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\\n done = True\\n else:\\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\\n # print(edge_to_remove)\\n\\n idx_to_remove = []\\n done = False\\n for j in range(edge_to_remove.shape[0]):\\n for k in range(final_edges.shape[0]):\\n if list(edge_to_remove[j]) == list(final_edges[k]):\\n if not done:\\n idx_to_remove = k\\n done = True\\n else:\\n idx_to_remove = np.append(idx_to_remove, k)\\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\\n # print(final_edges)\\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\\n # print(result_nodes)\\n return result_nodes, final_edges\",\n \"def merge_duplicate_nodes(self):\\n merges={}\\n xys={}\\n for n in self.valid_node_iter():\\n k=tuple(self.nodes['x'][n])\\n if k in xys:\\n merges[n]=xys[k]\\n self.merge_nodes(xys[k],n)\\n else:\\n xys[k]=n\\n return merges\",\n \"def pairs_of_vertices(self):\\n pairs_of_vertices = []\\n for vertice in self.list_of_vertices:\\n for edge in vertice.edges_list:\\n if non_oriented:\\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n if not non_oriented:\\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n return pairs_of_vertices\",\n \"def make_complete_graph(num_nodes):\\r\\n result = {}\\r\\n for idx in range(0,num_nodes):\\r\\n result[idx] = set([])\\r\\n for jdx in range(0,num_nodes):\\r\\n if (idx!=jdx):\\r\\n result[idx].add(jdx)\\r\\n return result\",\n \"def get_node_pairs_from_path(path):\\n\\n path = path[:-1]\\n pairs = []\\n for i in range(len(path)):\\n center_node = path[i]\\n for j in range(max(i - config.window_size, 0), min(i + config.window_size + 1, len(path))):\\n if i == j:\\n continue\\n node = path[j]\\n pairs.append([center_node, node])\\n return pairs\",\n \"def DFS(G: List, i: int, U: List) -> List:\\n node = G[i]\\n node.visited = True\\n U.remove(i)\\n for adj_node in node.adjacent:\\n if not adj_node.visited:\\n DFS(G, adj_node.value, U)\\n return [G, U]\",\n \"def visitEdges(self) -> None:\\n\\n for node in self.nodesMap_.values():\\n for nodeInput in node.get_inputs():\\n i = nodeInput[0]\\n if i.get_name() not in self.nodesMap_:\\n print(i.get_kind_name(), i.get_name())\\n edgeStr = self.get_unique_vertex_name(i) + \\\":Outputs -> \\\"\\n edgeStr += self.get_unique_vertex_name(node) + \\\":Inputs\\\"\\n self.edges_.append(edgeStr)\",\n \"def find_conflicts(graph):\\n for node in graph:\\n for neighbour in node.neighbours:\\n for n in neighbour.neighbours:\\n if n is node:\\n continue\\n _log.info(\\\"Nodes %s and %s are in conflict.\\\" % (node, n))\\n node.add_conflict_with_node(n)\\n n.add_conflict_with_node(node)\",\n \"def vertices(self):\\n \\n yielded = set()\\n \\n # Iterate over every tuple of edges, e.g. ..., (1, 2), (4, 3), ...\\n for vertices in self.edges():\\n # Iterate over every vertex in the tuple, e.g. ..., 1, 2, 4, 3, ...\\n for vertex in vertices:\\n # Yield if it has not been yielded already\\n if vertex not in yielded:\\n yield vertex\",\n \"def iter_node(self):\\n return self.d.keys()\",\n \"def junctions(self):\\n for node_name in self._junctions:\\n yield node_name, self._data[node_name]\",\n \"def iter_nodes(self, fields=None, **kwargs):\\n columns = ['uuid', 'driver'] + list(fields or ())\\n node_list = self.dbapi.get_nodeinfo_list(columns=columns, **kwargs)\\n for result in node_list:\\n if self._mapped_to_this_conductor(*result[:2]):\\n yield result\",\n \"def nodes(self):\\n nodes = []\\n for key, val in self._graph.items():\\n nodes.append(key)\\n nodes.extend([v for v in val.keys() if v not in nodes])\\n return set(nodes)\",\n \"def __iter__ (self, data=False):\\n return self.network.nodes_iter(data=data)\",\n \"def node_names(self):\\n\\n for node_name in self.nodes.keys():\\n\\n yield node_name\",\n \"def _create_connections(self):\\n self.predecessors = {}\\n self.successors = {}\\n for nd in self.nodes:\\n self.predecessors[nd.name] = []\\n self.successors[nd.name] = []\\n\\n for (nd_out, nd_in) in self.edges:\\n self.predecessors[nd_in.name].append(nd_out)\\n self.successors[nd_out.name].append(nd_in)\",\n \"def nodes_in_triangle(G, n):\\n triangle_nodes = set([n])\\n \\n # Iterate over all possible triangle relationship combinations\\n for n1, n2 in combinations(G.neighbors(n), 2):\\n \\n # Check if n1 and n2 have an edge between them\\n if G.has_edge(n1, n2):\\n \\n # Add n1 to triangle_nodes\\n triangle_nodes.add(n1)\\n \\n # Add n2 to triangle_nodes\\n triangle_nodes.add(n2)\\n \\n return triangle_nodes\",\n \"def generate_edges(graph):\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\",\n \"def gen_graph(self):\",\n \"def get_all_vertices(self):\\r\\n for vertex in self.__neighbours.keys():\\r\\n yield vertex\",\n \"def test_same_node_is_reachable(self):\\n # G is an arbitrary tournament on ten nodes.\\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\\n assert_true(all(is_reachable(G, v, v) for v in G))\",\n \"def getLinkList(self, graph_dict):\\n link_list = []\\n for vertex in graph_dict:\\n for neighbour in graph_dict[vertex]:\\n if {neighbour, vertex} not in link_list:\\n link_list.append({vertex, neighbour})\\n link_list = [x for x in link_list if len(x) > 1]\\n return link_list\",\n \"def __iter__(self) -> Iterable[Node]:\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def getPairList(nodeDict):\\n\\n\\tpairList = []\\n\\n\\tprint \\\"\\\\tGetting list of all node pairs...\\\"\\n\\n\\tfor key in nodeDict.keys():\\n\\t\\tprint \\\"\\\\t\\\\tLooking at node named '%s'...\\\" % key\\n\\t\\ttheNode = nodeDict[key]\\n\\t\\tconnectionsList = theNode[2]\\n\\t\\tif (connectionsList == None) or (connectionsList == []):\\n\\t\\t\\t# No connections, do nothing\\n\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tNode has no connections.\\\"\\n\\t\\t\\tpass\\n\\t\\telse:\\n\\t\\t\\tfor connection in connectionsList:\\n\\t\\t\\t\\tif (key < connection):\\n\\t\\t\\t\\t\\ttheTuple = (key, connection)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttheTuple = (connection, key)\\n\\t\\t\\t\\tif pairList.count(theTuple) == 0:\\n\\t\\t\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tConection between '%s' and '%s'.\\\" % theTuple\\n\\t\\t\\t\\t\\tpairList.append(theTuple)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tConection between '%s' and '%s' skipped. Dupe.\\\" % theTuple\\n\\n\\tprint \\\"\\\\tGot list of all node pairs (%d of 'em), sorting it...\\\" % (len(pairList))\\n\\n\\tpairList.sort()\\n\\n\\tprint \\\"\\\\tNode pair list sorted.\\\"\\n\\n\\treturn pairList\",\n \"def set_connection_between_nodes(self):\\n\\n for i, node in enumerate(self.list_empty_nodes):\\n line = node.labyrinth_position[0]\\n column = node.labyrinth_position[1]\\n\\n for j in range(i+1, len(self.list_empty_nodes)):\\n line_j = self.list_empty_nodes[j].labyrinth_position[0]\\n column_j = self.list_empty_nodes[j].labyrinth_position[1]\\n \\n if i != j and ((line == line_j and column == column_j - 1) \\\\\\n or (line == line_j and column == column_j + 1) \\\\\\n or (column == column_j and line == line_j - 1) \\\\\\n or (column == column_j and line == line_j + 1)) \\\\\\n and (not node in self.list_empty_nodes[j].connected_to) \\\\\\n and (not self.list_empty_nodes[j] in node.connected_to):\\n node.connected_to.append(self.list_empty_nodes[j])\\n self.list_empty_nodes[j].connected_to.append(node)\",\n \"def neighbours(self):\\n seen = set()\\n return [l.other(self) for l in self.dovetails \\\\\\n if id(l) not in seen and not seen.add(id(l))]\",\n \"def get_node_neighbors(\\n self, u: Hashable, include_metadata: bool = False\\n ) -> Generator:\\n if include_metadata:\\n return {\\n e[\\\"target\\\"]: _node_to_metadata(e[\\\"properties\\\"])\\n for e in (\\n self._g.V()\\n .has(ID, u)\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\", \\\"properties\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .by(__.valueMap(True))\\n .toList()\\n )\\n }\\n return self._g.V().has(ID, u).out().values(ID).toList()\",\n \"def graphs_iso(n):\\n assert n >= 0\\n for g in unique_iso(graphs(n)):\\n yield g\",\n \"def serialize_nx_node_to_triples(g, key, node=None):\\n\\n node = node or g and g.node.get(key) # <curie/key> # ... precis\\n\\n yield (key, 'a', node.get('type')) # <> a <type>\\n\\n for attr,value in node.items():\\n yield (key, attr, value)\\n\\n # MultiDiGraph\\n for edge in g.edge.get(key):\\n # multivalue edges\\n # <> linkTo _:ReifiedEdge\\n\\n # = BNode(), UUID\\n # = edge_url\\n s = '#e/'.join((key,uuid,))\\n yield (s, 'a', 'edgetype')\\n yield (s, 'linksFrom', key)\\n yield (s, 'linksTo', edge)\\n\\n for attr, value in edge.items():\\n yield (s, attr, edge.get(attr))\\n # _:ReifiedEdge attr[n] value[n]\",\n \"def find_selfloop_nodes(G):\\n nodes_in_selfloops = []\\n\\n # Iterate over all the edges of G\\n for u, v in G.edges:\\n if u == v: # Check if node u and node v are the same\\n nodes_in_selfloops.append(u) # Append node u to nodes_in_selfloops\\n return nodes_in_selfloops\",\n \"def basepairs(graph = None):\\n\\tbasepair_list = []\\n\\tfor line in nx.generate_edgelist(graph):\\n\\t\\tif ('basepair' in line):\\n\\t\\t\\tx = int(line.split(' ')[0])\\n\\t\\t\\ty = int(line.split(' ')[1])\\n\\t\\t\\tif not (((x,y) in basepair_list) or ((y,x) in basepair_list)):\\n\\t\\t\\t\\tbasepair_list.append((x,y))\\n\\treturn basepair_list\",\n \"def allReachable(g, n):\\n nodeList = []\\n \\n keysList = []\\n\\n for key in g.keys():\\n keysList.append(key)\\n \\n for i in keysList:\\n if findPath(g, n, i) != None:\\n nodeList.append(i)\\n \\n nodeList.sort()\\n nodeList.remove(n)\\n \\n return nodeList\",\n \"def graphs_conn_iso(n):\\n def graphs_conn_helper(n):\\n for oldg in graphs_conn_iso(n-1):\\n for s in powerset(range(n-1)):\\n if s == ():\\n continue\\n g = oldg + [list(s)]\\n for v in s:\\n g[v] = g[v] + [n-1]\\n # NOT g[v] += ... or g[v].append(...)\\n # to avoid changing items in oldg\\n yield g\\n\\n assert n >= 0\\n if n >= 3:\\n for g in unique_iso(graphs_conn_helper(n)):\\n yield g\\n elif n == 2:\\n yield [ [1], [0] ]\\n elif n == 1:\\n yield [ [] ]\\n else: # n == 0\\n yield []\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def graph_has_self_loops(edges):\\n\\n for a, b in edges:\\n if a == b:\\n return True\\n\\n return False\",\n \"def remove_stems(graph = None):\\n\\tfor x,y in basepairs(graph = graph):\\n\\t\\tgraph.remove_node(x)\\n\\t\\tgraph.remove_node(y)\",\n \"def clean_edges(self):\\n for from_node in self.all_nodes():\\n for to_node in self.all_nodes():\\n if from_node == to_node:\\n continue\\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\\n if len(dup) > 1:\\n for d in dup[1:]:\\n self.edges.remove(d)\",\n \"def __iter__(self) -> Iterable[\\\"AbstractLane\\\"]:\\n for origin in self.graph:\\n for destination in self.graph[origin]:\\n for index, lane in self.graph[origin][destination].items():\\n yield lane\",\n \"def get_pairs(self):\\n self.get_locations()\\n self.choices = {}\\n for host, pathogens in self.locations.iteritems():\\n if len(pathogens) > 1:\\n for pair in combinations(pathogens, 2):\\n self.choices.update({pair: host}) # pairs of pathogens in same host\",\n \"def graph(self):\\n ...\",\n \"def to_undirected_graph(self):\\n visited = set() \\n G = Graph.Graph()\\n \\n for node in self.node_set:\\n \\n if node not in visited:\\n visited.add(node)\\n for i in self.suffix[node]:\\n G.add_edge(node, i)\\n \\n return G\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68542266","0.6712754","0.6575832","0.6528945","0.64538825","0.6438056","0.6314288","0.62993896","0.6280058","0.6257878","0.62574124","0.625634","0.6213354","0.62093157","0.6184859","0.61808145","0.61796695","0.6145432","0.60995543","0.60977054","0.60902834","0.60635364","0.6036189","0.60259694","0.598934","0.5987208","0.59763455","0.5975638","0.59750134","0.59552693","0.59416366","0.59334356","0.592702","0.59266216","0.5913356","0.59068775","0.5889527","0.58800614","0.5875806","0.5868997","0.5850967","0.5831721","0.5828772","0.5821909","0.57760537","0.5775413","0.576808","0.5765285","0.57596123","0.57555616","0.5744718","0.5734772","0.572815","0.5719322","0.5710006","0.570776","0.5696583","0.56884235","0.56849253","0.56837505","0.5683528","0.56813353","0.56622297","0.5652679","0.56513375","0.5650365","0.5640035","0.5634748","0.5627695","0.5622776","0.5619673","0.5610282","0.5610028","0.5609062","0.5607356","0.55994576","0.55979633","0.55961543","0.55958337","0.55913615","0.55847245","0.55827004","0.5579414","0.5579021","0.55724883","0.5571925","0.5564694","0.556246","0.5559944","0.5557757","0.5557218","0.5554017","0.55519897","0.554881","0.55479807","0.5542983","0.55373377","0.5521824","0.5515768","0.55041164"],"string":"[\n \"0.68542266\",\n \"0.6712754\",\n \"0.6575832\",\n \"0.6528945\",\n \"0.64538825\",\n \"0.6438056\",\n \"0.6314288\",\n \"0.62993896\",\n \"0.6280058\",\n \"0.6257878\",\n \"0.62574124\",\n \"0.625634\",\n \"0.6213354\",\n \"0.62093157\",\n \"0.6184859\",\n \"0.61808145\",\n \"0.61796695\",\n \"0.6145432\",\n \"0.60995543\",\n \"0.60977054\",\n \"0.60902834\",\n \"0.60635364\",\n \"0.6036189\",\n \"0.60259694\",\n \"0.598934\",\n \"0.5987208\",\n \"0.59763455\",\n \"0.5975638\",\n \"0.59750134\",\n \"0.59552693\",\n \"0.59416366\",\n \"0.59334356\",\n \"0.592702\",\n \"0.59266216\",\n \"0.5913356\",\n \"0.59068775\",\n \"0.5889527\",\n \"0.58800614\",\n \"0.5875806\",\n \"0.5868997\",\n \"0.5850967\",\n \"0.5831721\",\n \"0.5828772\",\n \"0.5821909\",\n \"0.57760537\",\n \"0.5775413\",\n \"0.576808\",\n \"0.5765285\",\n \"0.57596123\",\n \"0.57555616\",\n \"0.5744718\",\n \"0.5734772\",\n \"0.572815\",\n \"0.5719322\",\n \"0.5710006\",\n \"0.570776\",\n \"0.5696583\",\n \"0.56884235\",\n \"0.56849253\",\n \"0.56837505\",\n \"0.5683528\",\n \"0.56813353\",\n \"0.56622297\",\n \"0.5652679\",\n \"0.56513375\",\n \"0.5650365\",\n \"0.5640035\",\n \"0.5634748\",\n \"0.5627695\",\n \"0.5622776\",\n \"0.5619673\",\n \"0.5610282\",\n \"0.5610028\",\n \"0.5609062\",\n \"0.5607356\",\n \"0.55994576\",\n \"0.55979633\",\n \"0.55961543\",\n \"0.55958337\",\n \"0.55913615\",\n \"0.55847245\",\n \"0.55827004\",\n \"0.5579414\",\n \"0.5579021\",\n \"0.55724883\",\n \"0.5571925\",\n \"0.5564694\",\n \"0.556246\",\n \"0.5559944\",\n \"0.5557757\",\n \"0.5557218\",\n \"0.5554017\",\n \"0.55519897\",\n \"0.554881\",\n \"0.55479807\",\n \"0.5542983\",\n \"0.55373377\",\n \"0.5521824\",\n \"0.5515768\",\n \"0.55041164\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.78772706"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20168,"cells":{"query":{"kind":"string","value":"Returns the set of all relations between a given pair of nodes"},"document":{"kind":"string","value":"def get_all_relations(graph, u, v):\n return {\n data[RELATION]\n for data in graph.edge[u][v].values()\n }"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))","def relations(self):\n return set(self.triples()[\"relation\"])","def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\"rel\"):\n s, o = int(s.id), int(o.id)\n yield {\"predicate\": p,\n \"subject\": s,\n \"subject_nodes\": list(self.get_descendants(s, triples)),\n \"object\": o,\n \"object_nodes\": list(self.get_descendants(o, triples)),\n }","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def get_all_relations(\n self,\n node: Tuple[str, str],\n relation: Optional[str] = None,\n ) -> List[Relation]:\n source_rels = self.get_source_relations(target=node, relation=relation)\n target_rels = self.get_target_relations(source=node, relation=relation)\n all_rels = source_rels + target_rels\n return all_rels","def relations_from(self, start_node):","def relations_to(self, end_node):","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n ntuple.sort()\n joinedTuple = \"\".join(ntuple)\n for nodeInTuple in ntuple:\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\n \n for a,v in ntuplesPerNode.iteritems():\n ntuplesPerNode[a] = set(v)\n \n return ntuplesPerNode","def graph_nodes(dependencies):\n\n return set.union(set(dependencies), *list(dependencies.values()))","def differentNodesForNode(ntupleSet,nodeList,verbose=False):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n nodesPerNode[a] = set(v)\n \n return nodesPerNode","def indirect(stack):\n g = nx.Graph(stack)\n for group in nx.connected_components(g):\n yield from map(frozenset, combinations(group, 2))","def get_related_edges(nodes_list, graph):\n\n node_id_list = map(lambda x: x.id, nodes_list)\n node_id_set = set(node_id_list)\n edges = []\n\n for node in nodes_list:\n if node.id in graph.incoming_edges:\n for edge in graph.incoming_edges[node.id]:\n\n if edge.start in node_id_set:\n edges.append(edge)\n\n return edges","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def get_pt_relations(self, pt_set1, pt_set2):\n raise NotImplementedError('Abstract Method.')","def edges(self, node):\n nID = self.n2ID[node]\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]","def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for neighbour in self.__graph_dict[node]:\n # Since all edges go both ways, we need only return one of them.\n if {neighbour, node} not in edges:\n edges.append({node, neighbour})\n yield (node, neighbour)","def get_descendants(self, node, triples, ignore=\"^(rel_|frame_)\"):\n children = defaultdict(list) # parent id : [child ids]\n inrelation = set() # ids of all nodes in a relation\n for s, p, o in triples:\n s, o = int(s.id), int(o.id)\n if p.startswith(\"rel_\"):\n children[o].append(s)\n elif not re.match(ignore, p):\n inrelation |= {s, o}\n seen = set()\n def getnodes(n):\n if n in seen:\n return\n seen.add(n)\n yield n\n for c in children[n]:\n if c not in inrelation:\n for n2 in getnodes(c):\n yield n2\n return getnodes(node)","def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v","def directed(self):\n seen = {}\n for up, down in self:\n if (up is None) or (down is None):\n continue #omit unpaired bases\n if up > down:\n up, down = down, up\n seen[(up, down)] = True\n result = seen.keys()\n return Pairs(result)","def _get_common_neighbour_node_pairs(self):\n node_pairs = []\n for node1 in self.graph.nodes():\n for node2 in self.graph.nodes():\n if node1 != node2:\n neighbour_count = self.neighbour_counts[(node1, node2)]\n if neighbour_count >= 1:\n node_pairs.append((node1, node2))\n return node_pairs","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def compute_relations(nodes: List[Node]) -> None:\n # Calculate parents\n for node in nodes:\n node.parents = []\n for node in nodes:\n for child in node.children():\n child.parents.append(node)\n\n def compute_dominators(\n entry: Node,\n parents: Callable[[Node], List[Node]],\n dominators: Callable[[Node], Set[Node]],\n immediately_dominates: Callable[[Node], List[Node]],\n set_immediate_dominator: Callable[[Node, Optional[Node]], None],\n ) -> None:\n # See https://en.wikipedia.org/wiki/Dominator_(graph_theory)#Algorithms\n # Note: if `n` is unreachable from `entry`, then *every* node will\n # vacuously belong to `n`'s dominator set.\n for n in nodes:\n dominators(n).clear()\n if n == entry:\n dominators(n).add(n)\n else:\n dominators(n).update(nodes)\n\n changes = True\n while changes:\n changes = False\n for node in nodes:\n if node == entry:\n continue\n nset = dominators(node)\n for parent in parents(node):\n nset = nset.intersection(dominators(parent))\n nset.add(node)\n if len(nset) < len(dominators(node)):\n assert nset.issubset(dominators(node))\n dominators(node).intersection_update(nset)\n changes = True\n\n # Compute immediate dominator, and the inverse relation\n for node in nodes:\n immediately_dominates(node).clear()\n for node in nodes:\n doms = dominators(node).difference({node})\n # If `node == entry` or the flow graph is not reducible, `doms` may be empty.\n # TODO: Infinite loops could be made reducible by introducing\n # branches like `if (false) { return; }` without breaking semantics\n if doms:\n # There should be a unique max `len(dominators(d))` if the flowgraph\n # is reducible. Fall back to largest index for irreducible graphs.\n imdom = max(doms, key=lambda d: (len(dominators(d)), d.block.index))\n immediately_dominates(imdom).append(node)\n set_immediate_dominator(node, imdom)\n else:\n set_immediate_dominator(node, None)\n for node in nodes:\n immediately_dominates(node).sort(key=lambda x: x.block.index)\n\n def _set_immediate_dominator(node: Node, imdom: Optional[Node]) -> None:\n node.immediate_dominator = imdom\n\n def _set_immediate_postdominator(node: Node, impdom: Optional[Node]) -> None:\n node.immediate_postdominator = impdom\n\n entry = nodes[0]\n terminal = nodes[-1]\n assert isinstance(terminal, TerminalNode)\n\n # Compute dominators & immediate dominators\n compute_dominators(\n entry=entry,\n parents=lambda n: n.parents,\n dominators=lambda n: n.dominators,\n immediately_dominates=lambda n: n.immediately_dominates,\n set_immediate_dominator=_set_immediate_dominator,\n )\n\n # Compute postdominators & immediate postdominators\n # This uses the same algorithm as above, but with edges reversed\n compute_dominators(\n entry=terminal,\n parents=lambda n: n.children(),\n dominators=lambda n: n.postdominators,\n immediately_dominates=lambda n: n.immediately_postdominates,\n set_immediate_dominator=_set_immediate_postdominator,\n )\n\n # Iterate over all edges n -> c and check for backedges, which define natural loops\n for node in nodes:\n for child in node.children():\n if child not in node.dominators:\n continue\n # Found a backedge node -> child where child dominates node; child is the \"head\" of the loop\n if child.loop is None:\n child.loop = NaturalLoop(child)\n child.loop.nodes |= {child, node}\n child.loop.backedges.add(node)\n for parent in nodes:\n if reachable_without(parent, node, child):\n child.loop.nodes.add(parent)","def findAll(tx):\n query = (\n \"MATCH (n1)-[r]->(n2) \"\n \"RETURN n1 AS node1 , r AS relationship , n2 AS node2 \"\n )\n\n result = tx.run(query)\n return [(record[\"node1\"], record[\"relationship\"], record[\"node2\"]) for record in result]","def getAllEdges(mutations):\n\tallEdges = []\n\tfor mutation in mutations: \n\t\tprint mutation\n\t\tfor mutation2 in mutations:\n\t\t\tif not (mutation == mutation2): # No edges connecting to themselves.\n\t\t\t\ttmp = []\n\t\t\t\ttmp.append(mutation)\n\t\t\t\ttmp.append(mutation2)\n\t\t\t\tallEdges.append(tmp)\n\treturn allEdges","def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\n if nbunch is None:\n nbunch = G\n else:\n nbunch = set(nbunch)\n\n directed = G.is_directed()\n if directed:\n iter_func = itertools.permutations\n else:\n iter_func = itertools.combinations\n\n all_pairs = {n: {} for n in nbunch}\n\n for u, v in iter_func(nbunch, 2):\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\n all_pairs[u][v] = k\n if not directed:\n all_pairs[v][u] = k\n\n return all_pairs","def connect_all(graph, nodeset):\n for element in nodeset:\n graph.add_node(element)\n for element1 in nodeset:\n for element2 in nodeset:\n if not element1 == element2:\n graph.add_edge(element1, element2)\n return graph","def GetInOutRelationsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.InputRelations][rel] = inRelations\n return res","def relations(self):\n\n def functions_helper(returned_set: set()):\n if is_relation(self.root): # Populate self.root and self.arguments\n returned_set.add((self.root, len(self.arguments)))\n\n elif is_equality(self.root): # Populate self.first and self.second\n return\n elif is_quantifier(self.root): # Populate self.variable and self.predicate\n returned_set.update(self.predicate.relations())\n\n elif is_unary(self.root): # Populate self.first\n returned_set.update(self.first.relations())\n\n else: # Populate self.first and self.second\n returned_set.update(self.first.relations())\n returned_set.update(self.second.relations())\n return\n\n \"\"\" Return a set of pairs (function_name, arity) for all function names\n that appear in this formula \"\"\"\n returned_set = set()\n functions_helper(returned_set)\n return returned_set\n\n # Ex12","def get_hierarchy(nodes):\n result = set()\n children = pm.listRelatives(nodes, children=True, fullPath=True)\n while children:\n result.update(children)\n children = pm.listRelatives(children, children=True, fullPath=True)\n\n result.update(nodes)\n return list(result)","def nodes_in_triangle(G, n):\n triangle_nodes = set([n])\n \n # Iterate over all possible triangle relationship combinations\n for n1, n2 in combinations(G.neighbors(n), 2):\n \n # Check if n1 and n2 have an edge between them\n if G.has_edge(n1, n2):\n \n # Add n1 to triangle_nodes\n triangle_nodes.add(n1)\n \n # Add n2 to triangle_nodes\n triangle_nodes.add(n2)\n \n return triangle_nodes","def edges(self):\n edge_list = []\n for node1 in self.node_dict:\n for node2 in self.node_dict[node1]:\n edge_list.append((node1,\n node2,\n self.node_dict[node1][node2]))\n return edge_list","def expand_paths_by_nodes(self, paths):\n paths_formatted = set()\n # Expand each path\n for path in paths:\n if len(path) < 2:\n continue\n expanded_paths = set()\n if self.include_entity:\n relations_for_each_step = [[path[0]]]\n else:\n relations_for_each_step = []\n for index in range(1, len(path)):\n node1 = path[index-1]\n node2 = path[index]\n if (node1, node2) in self.pair_to_relations:\n relations = self.pair_to_relations[(node1, node2)]\n else:\n print(node1, node2)\n relations_for_each_step.append(relations)\n if self.include_entity:\n relations_for_each_step.append([node2])\n expanded_paths.update(list(itertools.product(*relations_for_each_step)))\n paths_formatted.update(expanded_paths)\n return paths_formatted","def _find_paired_nodes(self, graph):\n paired_list = []\n for line in nx.generate_edgelist(graph):\n if ('basepair' in line):\n if not (int(line.split(' ')[0]) in paired_list):\n paired_list.append(int(line.split(' ')[0]))\n if not (int(line.split(' ')[1]) in paired_list):\n paired_list.append(int(line.split(' ')[1]))\n return paired_list","def getPairList(nodeDict):\n\n\tpairList = []\n\n\tprint \"\\tGetting list of all node pairs...\"\n\n\tfor key in nodeDict.keys():\n\t\tprint \"\\t\\tLooking at node named '%s'...\" % key\n\t\ttheNode = nodeDict[key]\n\t\tconnectionsList = theNode[2]\n\t\tif (connectionsList == None) or (connectionsList == []):\n\t\t\t# No connections, do nothing\n\t\t\tprint \"\\t\\t\\tNode has no connections.\"\n\t\t\tpass\n\t\telse:\n\t\t\tfor connection in connectionsList:\n\t\t\t\tif (key < connection):\n\t\t\t\t\ttheTuple = (key, connection)\n\t\t\t\telse:\n\t\t\t\t\ttheTuple = (connection, key)\n\t\t\t\tif pairList.count(theTuple) == 0:\n\t\t\t\t\tprint \"\\t\\t\\tConection between '%s' and '%s'.\" % theTuple\n\t\t\t\t\tpairList.append(theTuple)\n\t\t\t\telse:\n\t\t\t\t\tprint \"\\t\\t\\tConection between '%s' and '%s' skipped. Dupe.\" % theTuple\n\n\tprint \"\\tGot list of all node pairs (%d of 'em), sorting it...\" % (len(pairList))\n\n\tpairList.sort()\n\n\tprint \"\\tNode pair list sorted.\"\n\n\treturn pairList","def get_nodes_combinations(graph):\n nodes = graph.nodes()\n nodes_powerset = []\n for n in chain.from_iterable(combinations(nodes, r) for r in range(len(nodes)+1)):\n if len(n) > 1:\n nodes_powerset.append(list(n))\n return nodes_powerset","def get_relations(\n self,\n source: Optional[Tuple[str, str]] = None,\n target: Optional[Tuple[str, str]] = None,\n relation: Optional[str] = None,\n limit: Optional[int] = None,\n ) -> List[Relation]:\n if not source and not target:\n raise ValueError(\"source or target should be specified\")\n source = norm_id(*source) if source else None\n target = norm_id(*target) if target else None\n query = \"\"\"\n MATCH p=(%s)-[%s]->(%s)\n RETURN DISTINCT p\n %s\n \"\"\" % (\n \"{id: '%s'}\" % source if source else \"s\",\n \"\" if not relation else \":%s\" % relation,\n \"{id: '%s'}\" % target if target else \"t\",\n \"\" if not limit else \"LIMIT %s\" % limit,\n )\n rels = [self.neo4j_to_relation(res[0]) for res in self.query_tx(query)]\n return rels","def GetInOutRelationshipsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if rel in r[2]]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if rel in r[2]]\n res[gc.InputRelations][rel] = inRelations\n return res","def connecting(node1, node2):\n comp_list = []\n \"\"\":type : list[components.Component]\"\"\"\n if node1 == node2:\n return []\n for comp in node1.connected_comps:\n if comp.neg == node2:\n comp_list.append(comp)\n elif comp.pos == node2:\n comp_list.append(comp)\n return comp_list","def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\n\n n = len(aggr1)\n \n test_pairs = []\n for i in range(0, n):\n for j in range(0, n):\n if (aggr1[i] in table and aggr2[j] in table \n and (aggr1[i], aggr2[j]) in G.edges()\n ):\n test_pairs.append((aggr1[i], aggr2[j]))\n \n return test_pairs","def increasing_cover_relations(self):\n relations = []\n size = self.size()\n for i in range(1, size):\n for j in range(i + 1, size + 1):\n if self.le(i, j):\n relations.append((i, j))\n break\n return relations","def GetValRelations(self, G, node):\n res = {gc.InputRelations: [], gc.OutgoingRelations : []}\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.val in edge[2]]\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.val in edge[2]]\n res[gc.OutgoingRelations] = outEdges\n res[gc.InputRelations] = inEdges\n\n return res","def get_relations(bt, start=1):\n if not bt:\n return [], [], start # leaf\n lroots, lrelations, index = get_relations(bt[0], start=start)\n roots, relations, rindex = get_relations(bt[1], start=index + 1)\n roots.append(index)\n relations.extend(lrelations)\n relations.extend([(j, index) for j in lroots])\n return roots, relations, rindex","def nodes(self):\n\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))","def equivalent_subtree(chain_first: Any, chain_second: Any) -> List[Tuple[Any, Any]]:\n\n def structural_equivalent_nodes(node_first, node_second):\n nodes = []\n is_same_type = type(node_first) == type(node_second)\n node_first_childs = node_first.nodes_from\n node_second_childs = node_second.nodes_from\n if is_same_type and ((not node_first.nodes_from) or len(node_first_childs) == len(node_second_childs)):\n nodes.append((node_first, node_second))\n if node_first.nodes_from:\n for node1_child, node2_child in zip(node_first.nodes_from, node_second.nodes_from):\n nodes_set = structural_equivalent_nodes(node1_child, node2_child)\n if nodes_set:\n nodes += nodes_set\n return nodes\n\n pairs_set = structural_equivalent_nodes(chain_first.root_node, chain_second.root_node)\n assert isinstance(pairs_set, list)\n return pairs_set","def getMultipleEdgesBetweenSameNodesGraph(self):\n return create_quadEdgeCross(self)","def get_relations(bt, start=1):\n if not bt:\n return [], [], start # leaf\n roots, relations, index = get_relations(bt[0], start=start)\n rroots, rrelations, rindex = get_relations(bt[1], start=index + 1)\n roots.append(index)\n relations.extend(rrelations)\n relations.extend([(j, index) for j in rroots])\n return roots, relations, rindex","def get_connected_nodes(self, node):\n assert node in self.nodes, \"No node \"+str(node)+\" in graph \"+str(self)\n result = [x.node2 for x in self.edges if x.node1 == node]\n result += [x.node1 for x in self.edges if x.node2 == node]\n return sorted(result)","def get_target_relations(\n self,\n source: Tuple[str, str],\n relation: Optional[str] = None,\n ) -> List[Relation]:\n return self.get_relations(source=source, target=None, relation=relation)","def friend_pairs_and_other_friends(friend_tuple): \n x=friend_tuple[0]\n y=friend_tuple[1]\n def auxfun(w):\n return (frozenset({x,w}),y)\n return list(map(auxfun,y))#returns [({x,y[0]},y),...]","def get_common_sources(\n self, targets: List[Tuple[str, str]], relation: str\n ) -> List[Node]:\n rel_str = \":%s\" % relation if relation else \"\"\n parts = [\n \"(s)-[%s]->({id: '%s'})\" % (rel_str, norm_id(*target)) for target in targets\n ]\n query = \"\"\"\n MATCH %s\n RETURN DISTINCT s\n \"\"\" % \",\".join(\n parts\n )\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\n return nodes","def basepairs(graph = None):\n\tbasepair_list = []\n\tfor line in nx.generate_edgelist(graph):\n\t\tif ('basepair' in line):\n\t\t\tx = int(line.split(' ')[0])\n\t\t\ty = int(line.split(' ')[1])\n\t\t\tif not (((x,y) in basepair_list) or ((y,x) in basepair_list)):\n\t\t\t\tbasepair_list.append((x,y))\n\treturn basepair_list","def decreasing_cover_relations(self):\n relations = []\n for i in range(self.size(), 1, -1):\n for j in range(i - 1, 0, -1):\n if self.le(i, j):\n relations.append((i, j))\n break\n return relations","def getlinks2(topology, node1, node2):\n allLinks = topology.loadResources({\"resourceType\":\"Link\"})\n links = []\n for l in allLinks:\n (dstNode,dstPort) = linkednode2(l,node1)\n if (dstNode,dstPort) == (None, None):\n continue\n (dstNode,dstPort) = linkednode2(l,node2)\n if (dstNode,dstPort) == (None, None):\n continue\n links.append(l)\n return links","def edges(self):\n result = set() # avoid double-reporting edges of undirected graph\n for secondary_map in self._outgoing.values():\n result.update(secondary_map.values()) # add edges to resulting set\n return result","def pairs_of_vertices(self):\n pairs_of_vertices = []\n for vertice in self.list_of_vertices:\n for edge in vertice.edges_list:\n if non_oriented:\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n if not non_oriented:\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n return pairs_of_vertices","def getReferences(self, fromnode):\n\n node = self.findNode(fromnode)\n out_edges, _ = self.get_edges(node)\n return out_edges","def adjacent(self):\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\n result.remove(self)\n return result","def get_cross_synset_pairs(src_synset: Synset, dst_synset: Synset) -> list:\n # Remove phrasal expressions from the literals\n src_literals = remove_phrases(src_synset.literals)\n dst_literals = remove_phrases(dst_synset.literals)\n\n return unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in src_literals for w2 in dst_literals])","def get_right_edges(G,G2):\n\tsame_edges,different_edges=set(),set()\n\tfor e in G.edges():\n\t\tn1,n2=e\n\t\tif G2.has_edge(n1,n2): same_edges.add(e)\n\t\telse: different_edges.add(e)\n\treturn same_edges,different_edges","def relation_map(X, Y):\n info = {}\n for x,y in zip(X, Y):\n if x in info.keys():\n if y not in info[x]:\n info[x] = info[x] + [y]\n else: \n info[x] = [y]\n\n return info","def find_relationship(person1, person2):\n lines1 = get_ancestor_lines(person1)\n lines2 = get_ancestor_lines(person2)\n mrcas = find_most_recent(set(lines1).intersection(set(lines2)))\n\n relationships = []\n for anc in mrcas:\n relationships.append((lines1[anc], lines2[anc]))\n return relationships","def relationships(self):","def de2ue(edges):\n return set(de for de in edges if tuple(reversed(de)) in edges)","def get_synset_pairs(synset: Synset) -> list:\n # Remove phrasal expressions from the literals\n literals = remove_phrases(synset.literals)\n\n # Generate a list of unique pairs representing the cartesian product of the list of literals of the single synset\n pairs = unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in literals for w2 in literals if not w1 == w2])\n return pairs","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def nodesInTuples(setOfTuples):\n nodesList = []\n for tupl in setOfTuples:\n nodesList.extend(tupl)\n return list(set(nodesList))","def get_common_targets(\n self,\n sources: List[Tuple[str, str]],\n relation: str,\n ) -> List[Node]:\n rel_str = \":%s\" % relation if relation else \"\"\n parts = [\n \"({id: '%s'})-[%s]->(t)\" % (norm_id(*source), rel_str) for source in sources\n ]\n query = \"\"\"\n MATCH %s\n RETURN DISTINCT t\n \"\"\" % \",\".join(\n parts\n )\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\n return nodes","def _pivot_relations(relset, keymap, db):\n edges = []\n nodes = set()\n\n def add_edges(keys):\n for i in range(len(keys) - 1):\n for j in range(i + 1, len(keys)):\n edges.append((keys[i], keys[j]))\n\n for rel in relset:\n keys = keymap[rel]\n nodes.update(keys)\n add_edges(keys)\n\n pivots = set()\n components = util._connected_components(nodes, edges)\n while len(components) > 1:\n improved = False\n for rel, keys in keymap.items():\n if rel not in relset.union(pivots) and len(keys) > 1:\n if sum(1 if c.intersection(keys) else 0\n for c in components) > 1:\n nodes.update(keys)\n add_edges(keys)\n pivots.add(rel)\n improved = True\n break\n if not improved:\n raise TSQLError('could not find relation to join: {}'\n .format(', '.join(sorted(relset))))\n components = util._connected_components(nodes, edges)\n\n return pivots","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def _dag_dependents(db: Redis[bytes], dag_of: hash_t, op_from: hash_t) -> set[hash_t]:\n return __set_as_hashes(\n db, join(DAG_OPERATIONS, dag_of), join(OPERATIONS, op_from, \"children\")\n )","def get_edges(self) -> []:\n graph_edges = []\n\n for vertex in self.adj_list:\n for connection in self.adj_list[vertex]:\n if (vertex, connection) not in graph_edges and (connection, vertex) not in graph_edges:\n graph_edges.append((vertex, connection))\n\n return graph_edges","def relationships(self, r_type=None, n_ids=()):\n if r_type is None:\n r_sets = []\n else:\n r_sets = [self._relationships_by_type.get(r_type, frozenset())]\n if not n_ids or (hasattr(n_ids, \"__iter__\") and all(n_id is None for n_id in n_ids)):\n pass\n elif isinstance(n_ids, Sequence):\n for n_index, n_id in enumerate_nodes(n_ids):\n if n_id is not None:\n r_sets.append({r_id for r_id, i in self._relationships_by_node.get(n_id, ())\n if i == n_index})\n elif isinstance(n_ids, Set):\n for n_id in n_ids:\n if n_id is not None:\n r_sets.append({r_id for r_id, i in self._relationships_by_node.get(n_id, ())})\n else:\n raise TypeError(\"Nodes must be supplied as a Sequence or a Set\")\n if r_sets:\n return iter(reduce(and_operator, r_sets))\n else:\n return iter(self._relationships)","def matching_graph(n):\r\n k_n = nx.complete_graph(n)\r\n G = nx.Graph()\r\n for i in k_n.edges():\r\n G.add_node(i)\r\n w = []\r\n for i in k_n.edges():\r\n for j in k_n.edges():\r\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \r\n w.append((i,j))\r\n G.add_edge(i,j)\r\n return G","def make_nodes_and_paths(friends_lst):\n\n # nodes = {}\n\n # for item in friends_lst:\n # friend1, friend2, group = item\n # for person in pair:\n # if not nodes.get(person):\n # nodes[person] = pair[1]\n\n # nodes = [{'name': person, 'friend': nodes[person]} for person in nodes.keys()]\n\n nodes = {}\n for item in friends_lst:\n friend1, friend2, group = item\n if not nodes.get(friend1):\n nodes[friend1] = group\n elif nodes.get(friend1) > group:\n nodes[friend1] = group\n\n nodes = [{'name': person, 'group': nodes[person]} for person in nodes.keys()]\n\n index_nodes = {}\n for idx, n in enumerate(nodes):\n index_nodes[n['name']] = (idx, n['group'])\n\n paths = []\n\n # paths.append({'source': item[1], 'target': item[0]})\n\n for item in friends_lst:\n # one = User.query.get(item.user_id)\n # two = User.query.get(item.friend_id)\n source, target, group = item\n paths.append({'source': index_nodes[source][0], 'target': index_nodes[target][0]})\n\n # print nodes\n # print index_nodes\n # print paths\n\n return nodes, paths","def get_edges(self):\n return \\\n set({\n edge\n for node in self.nodeset\n for edge in node.get_incident_edges()\n })","def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\n n = len(nodes)\n return [(u, nodes[j % n])\n for i, u in enumerate(nodes)\n for j in range(i + 1, i + 1 + k // 2)]","def external_terminologies(self):\n terms = set()\n for node_record in self.graph.run(\"MATCH (n) RETURN (n)\"):\n node = node_record[\"n\"]\n if \"links_to\" in node:\n terms.add(node[\"links_to\"])\n return terms","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def findAllLiveRelationships(tx):\n query = (\n \"MATCH (n1:Person)-[r:LIVE]->(n2:House) \"\n \"RETURN ID(n1) , r , ID(n2);\"\n )\n results = tx.run(query).data()\n return results","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def cooccuranceBlock(ntupleSet,nodeList):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n differentNodes = set(v).difference(set([a]))\n NumberdifferentNodes = len(differentNodes) \n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\n \n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))","def get_dependencies(graph: Graph, node: Node):\n dependencies: Set[Node] = set()\n def traverse_nodes(nodes):\n for candidate in nodes:\n if candidate not in dependencies:\n dependencies.add(candidate)\n traverse_nodes(graph[candidate])\n traverse_nodes(graph[node])\n dependencies.discard(node)\n return dependencies","def _find_relations(self, node, depth=0):\n depth += 1\n\n model = node.model\n opts = model._meta\n\n # determine relational fields to determine paths\n forward_fields = opts.fields\n reverse_fields = opts.get_all_related_objects()\n\n forward_o2o = filter(self._filter_one2one, forward_fields)\n reverse_o2o = filter(self._filter_related_one2one, reverse_fields)\n\n forward_fk = filter(self._filter_fk, forward_fields)\n reverse_fk = filter(self._filter_related_fk, reverse_fields)\n\n forward_m2m = filter(self._filter_m2m, opts.many_to_many)\n reverse_m2m = filter(self._filter_related_m2m,\n opts.get_all_related_many_to_many_objects())\n\n # iterate m2m relations\n for f in forward_m2m:\n kwargs = {\n 'parent': node,\n 'model': f.rel.to,\n 'relation': 'manytomany',\n 'reverse': False,\n 'related_name': f.name,\n 'accessor_name': f.name,\n 'nullable': True,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n # iterate over related m2m fields\n for r in reverse_m2m:\n kwargs = {\n 'parent': node,\n 'model': r.model,\n 'relation': 'manytomany',\n 'reverse': True,\n 'related_name': r.field.related_query_name(),\n 'accessor_name': r.get_accessor_name(),\n 'nullable': True,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n # iterate over one2one fields\n for f in forward_o2o:\n kwargs = {\n 'parent': node,\n 'model': f.rel.to,\n 'relation': 'onetoone',\n 'reverse': False,\n 'related_name': f.name,\n 'accessor_name': f.name,\n 'nullable': False,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n # iterate over related one2one fields\n for r in reverse_o2o:\n kwargs = {\n 'parent': node,\n 'model': r.model,\n 'relation': 'onetoone',\n 'reverse': True,\n 'related_name': r.field.related_query_name(),\n 'accessor_name': r.get_accessor_name(),\n 'nullable': False,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n # iterate over fk fields\n for f in forward_fk:\n kwargs = {\n 'parent': node,\n 'model': f.rel.to,\n 'relation': 'foreignkey',\n 'reverse': False,\n 'related_name': f.name,\n 'accessor_name': f.name,\n 'nullable': f.null,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n # iterate over related foreign keys\n for r in reverse_fk:\n kwargs = {\n 'parent': node,\n 'model': r.model,\n 'relation': 'foreignkey',\n 'reverse': True,\n 'related_name': r.field.related_query_name(),\n 'accessor_name': r.get_accessor_name(),\n 'nullable': True,\n 'depth': depth,\n }\n self._add_node(**kwargs)\n\n return node","def find_relations(self, rid:int, *rids):\n first = set(self.rid_to_relations.get(rid, ()))\n if rids:\n return first.intersection(*[self.rid_to_relations.get(x, set()) for x in rids])\n return first","def connected_components(nodes):\n\n # List of connected components found. The order is random.\n result = []\n\n # Make a copy of the set, so we can modify it.\n nodes = set(nodes)\n\n # Iterate while we still have nodes to process.\n while nodes:\n\n # Get a random node and remove it from the global set.\n n = nodes.pop()\n\n # This set will contain the next group of nodes\n # connected to each other.\n group = {n}\n\n # Build a queue with this node in it.\n queue = [n]\n\n # Iterate the queue.\n # When it's empty, we finished visiting a group of connected nodes.\n while queue:\n\n # Consume the next item from the queue.\n n = queue.pop(0)\n\n # Fetch the neighbors.\n neighbors = n.links\n\n # Remove the neighbors we already visited.\n neighbors.difference_update(group)\n\n # Remove the remaining nodes from the global set.\n nodes.difference_update(neighbors)\n\n # Add them to the group of connected nodes.\n group.update(neighbors)\n\n # Add them to the queue, so we visit them in the next iterations.\n queue.extend(neighbors)\n\n # Add the group to the list of groups.\n result.append(group)\n\n # Return the list of groups.\n return result","def common_dependency_targets(graph1, graph2, n1, n2, node_attrib='label',\n edge_attrib='label'):\n n1_children = dependency_children(graph1, n1, edge_attrib=edge_attrib)\n n2_children = dependency_children(graph2, n2, edge_attrib=edge_attrib)\n n1_rels, n2_rels = defaultdict(list), defaultdict(list)\n\n for source_set, target_dict in ((n1_children, n1_rels), (n2_children, n2_rels)):\n for rel, target in source_set:\n target_dict[rel].append(target)\n\n common_rels = set(n1_rels) & set(n2_rels) # intersection\n common_deps = set()\n for rel in common_rels:\n for n1_target in n1_rels[rel]:\n n1_target_word = graph1.node[n1_target][node_attrib]\n for n2_target in n2_rels[rel]:\n n2_target_word = graph2.node[n2_target][node_attrib]\n if n1_target_word == n2_target_word:\n common_deps.add( (n1_target, n2_target) )\n return common_deps","def get_other_neighbors(self, node):\n neighbors = self.get_neighbors()\n return list(set(neighbors) - set([node]))","def get_connected_nodes(self, adj_keys: Publication, node_id: str) -> Set[str]:\n import networkx as nx\n\n edges = set()\n graph = nx.Graph()\n for adj_value in adj_keys.keyVals.values():\n if adj_value.value:\n adj_db = deserialize(openr_types.AdjacencyDatabase, adj_value.value)\n else:\n adj_db = openr_types.AdjacencyDatabase()\n graph.add_node(adj_db.thisNodeName)\n for adj in adj_db.adjacencies:\n # Add edge only when we see the reverse side of it.\n if (adj.otherNodeName, adj_db.thisNodeName, adj.otherIfName) in edges:\n graph.add_edge(adj.otherNodeName, adj_db.thisNodeName)\n continue\n edges.add((adj_db.thisNodeName, adj.otherNodeName, adj.ifName))\n # pyre-ignore[16]\n return nx.node_connected_component(graph, node_id)","def find_independent(self) -> list:\n results = list() # our results list that\n for node in self.network:\n # Checks if the dependencies actually doesnt exist\n if (node.get_dependencies() in [None, list(), tuple(), set()]):\n results.append(node)\n return results","def find_connected_links(self, node):\n connected_link_set = []\n if node in self.outgoing_links:\n for links in self.outgoing_links[node].values():\n connected_link_set.extend(links)\n \n if node in self.incoming_links:\n for links in self.incoming_links[node].values():\n connected_link_set.extend(links)\n \n return connected_link_set","def likely_pairs(self, k=2):\n for a in self.G.nodes():\n if not self.eligible_node(a):\n continue\n for b in neighbourhood(self.G, a, k):\n if not self.eligible_node(b):\n continue\n yield (a, b)","def joint_graph(graph, nodes):\n # TODO\n joint_graph = nodes = None\n\n return joint_graph, nodes","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def get_edges(self):\n return_set = set()\n for outer_index, outer_list in enumerate(self._adjmatrix):\n for inner_index, inner_item in enumerate(outer_list):\n if(inner_item):\n return_set.add(\n (self._name[outer_index],\n self._name[inner_index]))\n return return_set","def get_edge_ids(self):\n node_ids = self.node_ids\n return [(node_ids[0], node_ids[1])]","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({neighbour, vertex})\n return edges","def read_nell_relations():\n\trel=os.walk(\"nell/relations\")\n\trelation=[]\n\tfor i in rel:\n\t\ttrel=i[2]\n\tfor i in trel:\n\t\trelation.append(' '.join(segment(i.split(':')[1])))\n\treturn relation","def neighbors(node, test_set):\r\n result = set()\r\n for neighbor in node.neighbors:\r\n if neighbor in test_set:\r\n result.add(neighbor)\r\n return result","def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))"],"string":"[\n \"def all_pairs(self):\\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))\",\n \"def relations(self):\\n return set(self.triples()[\\\"relation\\\"])\",\n \"def get_relations(self):\\n triples = list(self.get_triples())\\n\\n for s, p, o in triples:\\n if not p.startswith(\\\"rel\\\"):\\n s, o = int(s.id), int(o.id)\\n yield {\\\"predicate\\\": p,\\n \\\"subject\\\": s,\\n \\\"subject_nodes\\\": list(self.get_descendants(s, triples)),\\n \\\"object\\\": o,\\n \\\"object_nodes\\\": list(self.get_descendants(o, triples)),\\n }\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def get_all_relations(\\n self,\\n node: Tuple[str, str],\\n relation: Optional[str] = None,\\n ) -> List[Relation]:\\n source_rels = self.get_source_relations(target=node, relation=relation)\\n target_rels = self.get_target_relations(source=node, relation=relation)\\n all_rels = source_rels + target_rels\\n return all_rels\",\n \"def relations_from(self, start_node):\",\n \"def relations_to(self, end_node):\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def differentNTuplesForNode(ntupleSet,nodeList,verbose=False):\\n ntuplesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n ntuple.sort()\\n joinedTuple = \\\"\\\".join(ntuple)\\n for nodeInTuple in ntuple:\\n ntuplesPerNode[nodeInTuple].append(joinedTuple)\\n \\n for a,v in ntuplesPerNode.iteritems():\\n ntuplesPerNode[a] = set(v)\\n \\n return ntuplesPerNode\",\n \"def graph_nodes(dependencies):\\n\\n return set.union(set(dependencies), *list(dependencies.values()))\",\n \"def differentNodesForNode(ntupleSet,nodeList,verbose=False):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n nodesPerNode[a] = set(v)\\n \\n return nodesPerNode\",\n \"def indirect(stack):\\n g = nx.Graph(stack)\\n for group in nx.connected_components(g):\\n yield from map(frozenset, combinations(group, 2))\",\n \"def get_related_edges(nodes_list, graph):\\n\\n node_id_list = map(lambda x: x.id, nodes_list)\\n node_id_set = set(node_id_list)\\n edges = []\\n\\n for node in nodes_list:\\n if node.id in graph.incoming_edges:\\n for edge in graph.incoming_edges[node.id]:\\n\\n if edge.start in node_id_set:\\n edges.append(edge)\\n\\n return edges\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def get_pt_relations(self, pt_set1, pt_set2):\\n raise NotImplementedError('Abstract Method.')\",\n \"def edges(self, node):\\n nID = self.n2ID[node]\\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]\",\n \"def edges(self) -> Iterable[Tuple[Node]]:\\n edges = []\\n for node in self.__graph_dict.keys():\\n for neighbour in self.__graph_dict[node]:\\n # Since all edges go both ways, we need only return one of them.\\n if {neighbour, node} not in edges:\\n edges.append({node, neighbour})\\n yield (node, neighbour)\",\n \"def get_descendants(self, node, triples, ignore=\\\"^(rel_|frame_)\\\"):\\n children = defaultdict(list) # parent id : [child ids]\\n inrelation = set() # ids of all nodes in a relation\\n for s, p, o in triples:\\n s, o = int(s.id), int(o.id)\\n if p.startswith(\\\"rel_\\\"):\\n children[o].append(s)\\n elif not re.match(ignore, p):\\n inrelation |= {s, o}\\n seen = set()\\n def getnodes(n):\\n if n in seen:\\n return\\n seen.add(n)\\n yield n\\n for c in children[n]:\\n if c not in inrelation:\\n for n2 in getnodes(c):\\n yield n2\\n return getnodes(node)\",\n \"def _iter_pairs(graph):\\n for u, v in set(graph.edges_iter()):\\n yield u, v\",\n \"def directed(self):\\n seen = {}\\n for up, down in self:\\n if (up is None) or (down is None):\\n continue #omit unpaired bases\\n if up > down:\\n up, down = down, up\\n seen[(up, down)] = True\\n result = seen.keys()\\n return Pairs(result)\",\n \"def _get_common_neighbour_node_pairs(self):\\n node_pairs = []\\n for node1 in self.graph.nodes():\\n for node2 in self.graph.nodes():\\n if node1 != node2:\\n neighbour_count = self.neighbour_counts[(node1, node2)]\\n if neighbour_count >= 1:\\n node_pairs.append((node1, node2))\\n return node_pairs\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def compute_relations(nodes: List[Node]) -> None:\\n # Calculate parents\\n for node in nodes:\\n node.parents = []\\n for node in nodes:\\n for child in node.children():\\n child.parents.append(node)\\n\\n def compute_dominators(\\n entry: Node,\\n parents: Callable[[Node], List[Node]],\\n dominators: Callable[[Node], Set[Node]],\\n immediately_dominates: Callable[[Node], List[Node]],\\n set_immediate_dominator: Callable[[Node, Optional[Node]], None],\\n ) -> None:\\n # See https://en.wikipedia.org/wiki/Dominator_(graph_theory)#Algorithms\\n # Note: if `n` is unreachable from `entry`, then *every* node will\\n # vacuously belong to `n`'s dominator set.\\n for n in nodes:\\n dominators(n).clear()\\n if n == entry:\\n dominators(n).add(n)\\n else:\\n dominators(n).update(nodes)\\n\\n changes = True\\n while changes:\\n changes = False\\n for node in nodes:\\n if node == entry:\\n continue\\n nset = dominators(node)\\n for parent in parents(node):\\n nset = nset.intersection(dominators(parent))\\n nset.add(node)\\n if len(nset) < len(dominators(node)):\\n assert nset.issubset(dominators(node))\\n dominators(node).intersection_update(nset)\\n changes = True\\n\\n # Compute immediate dominator, and the inverse relation\\n for node in nodes:\\n immediately_dominates(node).clear()\\n for node in nodes:\\n doms = dominators(node).difference({node})\\n # If `node == entry` or the flow graph is not reducible, `doms` may be empty.\\n # TODO: Infinite loops could be made reducible by introducing\\n # branches like `if (false) { return; }` without breaking semantics\\n if doms:\\n # There should be a unique max `len(dominators(d))` if the flowgraph\\n # is reducible. Fall back to largest index for irreducible graphs.\\n imdom = max(doms, key=lambda d: (len(dominators(d)), d.block.index))\\n immediately_dominates(imdom).append(node)\\n set_immediate_dominator(node, imdom)\\n else:\\n set_immediate_dominator(node, None)\\n for node in nodes:\\n immediately_dominates(node).sort(key=lambda x: x.block.index)\\n\\n def _set_immediate_dominator(node: Node, imdom: Optional[Node]) -> None:\\n node.immediate_dominator = imdom\\n\\n def _set_immediate_postdominator(node: Node, impdom: Optional[Node]) -> None:\\n node.immediate_postdominator = impdom\\n\\n entry = nodes[0]\\n terminal = nodes[-1]\\n assert isinstance(terminal, TerminalNode)\\n\\n # Compute dominators & immediate dominators\\n compute_dominators(\\n entry=entry,\\n parents=lambda n: n.parents,\\n dominators=lambda n: n.dominators,\\n immediately_dominates=lambda n: n.immediately_dominates,\\n set_immediate_dominator=_set_immediate_dominator,\\n )\\n\\n # Compute postdominators & immediate postdominators\\n # This uses the same algorithm as above, but with edges reversed\\n compute_dominators(\\n entry=terminal,\\n parents=lambda n: n.children(),\\n dominators=lambda n: n.postdominators,\\n immediately_dominates=lambda n: n.immediately_postdominates,\\n set_immediate_dominator=_set_immediate_postdominator,\\n )\\n\\n # Iterate over all edges n -> c and check for backedges, which define natural loops\\n for node in nodes:\\n for child in node.children():\\n if child not in node.dominators:\\n continue\\n # Found a backedge node -> child where child dominates node; child is the \\\"head\\\" of the loop\\n if child.loop is None:\\n child.loop = NaturalLoop(child)\\n child.loop.nodes |= {child, node}\\n child.loop.backedges.add(node)\\n for parent in nodes:\\n if reachable_without(parent, node, child):\\n child.loop.nodes.add(parent)\",\n \"def findAll(tx):\\n query = (\\n \\\"MATCH (n1)-[r]->(n2) \\\"\\n \\\"RETURN n1 AS node1 , r AS relationship , n2 AS node2 \\\"\\n )\\n\\n result = tx.run(query)\\n return [(record[\\\"node1\\\"], record[\\\"relationship\\\"], record[\\\"node2\\\"]) for record in result]\",\n \"def getAllEdges(mutations):\\n\\tallEdges = []\\n\\tfor mutation in mutations: \\n\\t\\tprint mutation\\n\\t\\tfor mutation2 in mutations:\\n\\t\\t\\tif not (mutation == mutation2): # No edges connecting to themselves.\\n\\t\\t\\t\\ttmp = []\\n\\t\\t\\t\\ttmp.append(mutation)\\n\\t\\t\\t\\ttmp.append(mutation2)\\n\\t\\t\\t\\tallEdges.append(tmp)\\n\\treturn allEdges\",\n \"def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\\n if nbunch is None:\\n nbunch = G\\n else:\\n nbunch = set(nbunch)\\n\\n directed = G.is_directed()\\n if directed:\\n iter_func = itertools.permutations\\n else:\\n iter_func = itertools.combinations\\n\\n all_pairs = {n: {} for n in nbunch}\\n\\n for u, v in iter_func(nbunch, 2):\\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\\n all_pairs[u][v] = k\\n if not directed:\\n all_pairs[v][u] = k\\n\\n return all_pairs\",\n \"def connect_all(graph, nodeset):\\n for element in nodeset:\\n graph.add_node(element)\\n for element1 in nodeset:\\n for element2 in nodeset:\\n if not element1 == element2:\\n graph.add_edge(element1, element2)\\n return graph\",\n \"def GetInOutRelationsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def relations(self):\\n\\n def functions_helper(returned_set: set()):\\n if is_relation(self.root): # Populate self.root and self.arguments\\n returned_set.add((self.root, len(self.arguments)))\\n\\n elif is_equality(self.root): # Populate self.first and self.second\\n return\\n elif is_quantifier(self.root): # Populate self.variable and self.predicate\\n returned_set.update(self.predicate.relations())\\n\\n elif is_unary(self.root): # Populate self.first\\n returned_set.update(self.first.relations())\\n\\n else: # Populate self.first and self.second\\n returned_set.update(self.first.relations())\\n returned_set.update(self.second.relations())\\n return\\n\\n \\\"\\\"\\\" Return a set of pairs (function_name, arity) for all function names\\n that appear in this formula \\\"\\\"\\\"\\n returned_set = set()\\n functions_helper(returned_set)\\n return returned_set\\n\\n # Ex12\",\n \"def get_hierarchy(nodes):\\n result = set()\\n children = pm.listRelatives(nodes, children=True, fullPath=True)\\n while children:\\n result.update(children)\\n children = pm.listRelatives(children, children=True, fullPath=True)\\n\\n result.update(nodes)\\n return list(result)\",\n \"def nodes_in_triangle(G, n):\\n triangle_nodes = set([n])\\n \\n # Iterate over all possible triangle relationship combinations\\n for n1, n2 in combinations(G.neighbors(n), 2):\\n \\n # Check if n1 and n2 have an edge between them\\n if G.has_edge(n1, n2):\\n \\n # Add n1 to triangle_nodes\\n triangle_nodes.add(n1)\\n \\n # Add n2 to triangle_nodes\\n triangle_nodes.add(n2)\\n \\n return triangle_nodes\",\n \"def edges(self):\\n edge_list = []\\n for node1 in self.node_dict:\\n for node2 in self.node_dict[node1]:\\n edge_list.append((node1,\\n node2,\\n self.node_dict[node1][node2]))\\n return edge_list\",\n \"def expand_paths_by_nodes(self, paths):\\n paths_formatted = set()\\n # Expand each path\\n for path in paths:\\n if len(path) < 2:\\n continue\\n expanded_paths = set()\\n if self.include_entity:\\n relations_for_each_step = [[path[0]]]\\n else:\\n relations_for_each_step = []\\n for index in range(1, len(path)):\\n node1 = path[index-1]\\n node2 = path[index]\\n if (node1, node2) in self.pair_to_relations:\\n relations = self.pair_to_relations[(node1, node2)]\\n else:\\n print(node1, node2)\\n relations_for_each_step.append(relations)\\n if self.include_entity:\\n relations_for_each_step.append([node2])\\n expanded_paths.update(list(itertools.product(*relations_for_each_step)))\\n paths_formatted.update(expanded_paths)\\n return paths_formatted\",\n \"def _find_paired_nodes(self, graph):\\n paired_list = []\\n for line in nx.generate_edgelist(graph):\\n if ('basepair' in line):\\n if not (int(line.split(' ')[0]) in paired_list):\\n paired_list.append(int(line.split(' ')[0]))\\n if not (int(line.split(' ')[1]) in paired_list):\\n paired_list.append(int(line.split(' ')[1]))\\n return paired_list\",\n \"def getPairList(nodeDict):\\n\\n\\tpairList = []\\n\\n\\tprint \\\"\\\\tGetting list of all node pairs...\\\"\\n\\n\\tfor key in nodeDict.keys():\\n\\t\\tprint \\\"\\\\t\\\\tLooking at node named '%s'...\\\" % key\\n\\t\\ttheNode = nodeDict[key]\\n\\t\\tconnectionsList = theNode[2]\\n\\t\\tif (connectionsList == None) or (connectionsList == []):\\n\\t\\t\\t# No connections, do nothing\\n\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tNode has no connections.\\\"\\n\\t\\t\\tpass\\n\\t\\telse:\\n\\t\\t\\tfor connection in connectionsList:\\n\\t\\t\\t\\tif (key < connection):\\n\\t\\t\\t\\t\\ttheTuple = (key, connection)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\ttheTuple = (connection, key)\\n\\t\\t\\t\\tif pairList.count(theTuple) == 0:\\n\\t\\t\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tConection between '%s' and '%s'.\\\" % theTuple\\n\\t\\t\\t\\t\\tpairList.append(theTuple)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tprint \\\"\\\\t\\\\t\\\\tConection between '%s' and '%s' skipped. Dupe.\\\" % theTuple\\n\\n\\tprint \\\"\\\\tGot list of all node pairs (%d of 'em), sorting it...\\\" % (len(pairList))\\n\\n\\tpairList.sort()\\n\\n\\tprint \\\"\\\\tNode pair list sorted.\\\"\\n\\n\\treturn pairList\",\n \"def get_nodes_combinations(graph):\\n nodes = graph.nodes()\\n nodes_powerset = []\\n for n in chain.from_iterable(combinations(nodes, r) for r in range(len(nodes)+1)):\\n if len(n) > 1:\\n nodes_powerset.append(list(n))\\n return nodes_powerset\",\n \"def get_relations(\\n self,\\n source: Optional[Tuple[str, str]] = None,\\n target: Optional[Tuple[str, str]] = None,\\n relation: Optional[str] = None,\\n limit: Optional[int] = None,\\n ) -> List[Relation]:\\n if not source and not target:\\n raise ValueError(\\\"source or target should be specified\\\")\\n source = norm_id(*source) if source else None\\n target = norm_id(*target) if target else None\\n query = \\\"\\\"\\\"\\n MATCH p=(%s)-[%s]->(%s)\\n RETURN DISTINCT p\\n %s\\n \\\"\\\"\\\" % (\\n \\\"{id: '%s'}\\\" % source if source else \\\"s\\\",\\n \\\"\\\" if not relation else \\\":%s\\\" % relation,\\n \\\"{id: '%s'}\\\" % target if target else \\\"t\\\",\\n \\\"\\\" if not limit else \\\"LIMIT %s\\\" % limit,\\n )\\n rels = [self.neo4j_to_relation(res[0]) for res in self.query_tx(query)]\\n return rels\",\n \"def GetInOutRelationshipsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if rel in r[2]]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if rel in r[2]]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def connecting(node1, node2):\\n comp_list = []\\n \\\"\\\"\\\":type : list[components.Component]\\\"\\\"\\\"\\n if node1 == node2:\\n return []\\n for comp in node1.connected_comps:\\n if comp.neg == node2:\\n comp_list.append(comp)\\n elif comp.pos == node2:\\n comp_list.append(comp)\\n return comp_list\",\n \"def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\\n\\n n = len(aggr1)\\n \\n test_pairs = []\\n for i in range(0, n):\\n for j in range(0, n):\\n if (aggr1[i] in table and aggr2[j] in table \\n and (aggr1[i], aggr2[j]) in G.edges()\\n ):\\n test_pairs.append((aggr1[i], aggr2[j]))\\n \\n return test_pairs\",\n \"def increasing_cover_relations(self):\\n relations = []\\n size = self.size()\\n for i in range(1, size):\\n for j in range(i + 1, size + 1):\\n if self.le(i, j):\\n relations.append((i, j))\\n break\\n return relations\",\n \"def GetValRelations(self, G, node):\\n res = {gc.InputRelations: [], gc.OutgoingRelations : []}\\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.val in edge[2]]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.val in edge[2]]\\n res[gc.OutgoingRelations] = outEdges\\n res[gc.InputRelations] = inEdges\\n\\n return res\",\n \"def get_relations(bt, start=1):\\n if not bt:\\n return [], [], start # leaf\\n lroots, lrelations, index = get_relations(bt[0], start=start)\\n roots, relations, rindex = get_relations(bt[1], start=index + 1)\\n roots.append(index)\\n relations.extend(lrelations)\\n relations.extend([(j, index) for j in lroots])\\n return roots, relations, rindex\",\n \"def nodes(self):\\n\\n return list(set(self._graph.keys() + [x for x in itertools.chain.from_iterable(self._graph.values())]))\",\n \"def equivalent_subtree(chain_first: Any, chain_second: Any) -> List[Tuple[Any, Any]]:\\n\\n def structural_equivalent_nodes(node_first, node_second):\\n nodes = []\\n is_same_type = type(node_first) == type(node_second)\\n node_first_childs = node_first.nodes_from\\n node_second_childs = node_second.nodes_from\\n if is_same_type and ((not node_first.nodes_from) or len(node_first_childs) == len(node_second_childs)):\\n nodes.append((node_first, node_second))\\n if node_first.nodes_from:\\n for node1_child, node2_child in zip(node_first.nodes_from, node_second.nodes_from):\\n nodes_set = structural_equivalent_nodes(node1_child, node2_child)\\n if nodes_set:\\n nodes += nodes_set\\n return nodes\\n\\n pairs_set = structural_equivalent_nodes(chain_first.root_node, chain_second.root_node)\\n assert isinstance(pairs_set, list)\\n return pairs_set\",\n \"def getMultipleEdgesBetweenSameNodesGraph(self):\\n return create_quadEdgeCross(self)\",\n \"def get_relations(bt, start=1):\\n if not bt:\\n return [], [], start # leaf\\n roots, relations, index = get_relations(bt[0], start=start)\\n rroots, rrelations, rindex = get_relations(bt[1], start=index + 1)\\n roots.append(index)\\n relations.extend(rrelations)\\n relations.extend([(j, index) for j in rroots])\\n return roots, relations, rindex\",\n \"def get_connected_nodes(self, node):\\n assert node in self.nodes, \\\"No node \\\"+str(node)+\\\" in graph \\\"+str(self)\\n result = [x.node2 for x in self.edges if x.node1 == node]\\n result += [x.node1 for x in self.edges if x.node2 == node]\\n return sorted(result)\",\n \"def get_target_relations(\\n self,\\n source: Tuple[str, str],\\n relation: Optional[str] = None,\\n ) -> List[Relation]:\\n return self.get_relations(source=source, target=None, relation=relation)\",\n \"def friend_pairs_and_other_friends(friend_tuple): \\n x=friend_tuple[0]\\n y=friend_tuple[1]\\n def auxfun(w):\\n return (frozenset({x,w}),y)\\n return list(map(auxfun,y))#returns [({x,y[0]},y),...]\",\n \"def get_common_sources(\\n self, targets: List[Tuple[str, str]], relation: str\\n ) -> List[Node]:\\n rel_str = \\\":%s\\\" % relation if relation else \\\"\\\"\\n parts = [\\n \\\"(s)-[%s]->({id: '%s'})\\\" % (rel_str, norm_id(*target)) for target in targets\\n ]\\n query = \\\"\\\"\\\"\\n MATCH %s\\n RETURN DISTINCT s\\n \\\"\\\"\\\" % \\\",\\\".join(\\n parts\\n )\\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\\n return nodes\",\n \"def basepairs(graph = None):\\n\\tbasepair_list = []\\n\\tfor line in nx.generate_edgelist(graph):\\n\\t\\tif ('basepair' in line):\\n\\t\\t\\tx = int(line.split(' ')[0])\\n\\t\\t\\ty = int(line.split(' ')[1])\\n\\t\\t\\tif not (((x,y) in basepair_list) or ((y,x) in basepair_list)):\\n\\t\\t\\t\\tbasepair_list.append((x,y))\\n\\treturn basepair_list\",\n \"def decreasing_cover_relations(self):\\n relations = []\\n for i in range(self.size(), 1, -1):\\n for j in range(i - 1, 0, -1):\\n if self.le(i, j):\\n relations.append((i, j))\\n break\\n return relations\",\n \"def getlinks2(topology, node1, node2):\\n allLinks = topology.loadResources({\\\"resourceType\\\":\\\"Link\\\"})\\n links = []\\n for l in allLinks:\\n (dstNode,dstPort) = linkednode2(l,node1)\\n if (dstNode,dstPort) == (None, None):\\n continue\\n (dstNode,dstPort) = linkednode2(l,node2)\\n if (dstNode,dstPort) == (None, None):\\n continue\\n links.append(l)\\n return links\",\n \"def edges(self):\\n result = set() # avoid double-reporting edges of undirected graph\\n for secondary_map in self._outgoing.values():\\n result.update(secondary_map.values()) # add edges to resulting set\\n return result\",\n \"def pairs_of_vertices(self):\\n pairs_of_vertices = []\\n for vertice in self.list_of_vertices:\\n for edge in vertice.edges_list:\\n if non_oriented:\\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n if not non_oriented:\\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n return pairs_of_vertices\",\n \"def getReferences(self, fromnode):\\n\\n node = self.findNode(fromnode)\\n out_edges, _ = self.get_edges(node)\\n return out_edges\",\n \"def adjacent(self):\\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\\n result.remove(self)\\n return result\",\n \"def get_cross_synset_pairs(src_synset: Synset, dst_synset: Synset) -> list:\\n # Remove phrasal expressions from the literals\\n src_literals = remove_phrases(src_synset.literals)\\n dst_literals = remove_phrases(dst_synset.literals)\\n\\n return unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in src_literals for w2 in dst_literals])\",\n \"def get_right_edges(G,G2):\\n\\tsame_edges,different_edges=set(),set()\\n\\tfor e in G.edges():\\n\\t\\tn1,n2=e\\n\\t\\tif G2.has_edge(n1,n2): same_edges.add(e)\\n\\t\\telse: different_edges.add(e)\\n\\treturn same_edges,different_edges\",\n \"def relation_map(X, Y):\\n info = {}\\n for x,y in zip(X, Y):\\n if x in info.keys():\\n if y not in info[x]:\\n info[x] = info[x] + [y]\\n else: \\n info[x] = [y]\\n\\n return info\",\n \"def find_relationship(person1, person2):\\n lines1 = get_ancestor_lines(person1)\\n lines2 = get_ancestor_lines(person2)\\n mrcas = find_most_recent(set(lines1).intersection(set(lines2)))\\n\\n relationships = []\\n for anc in mrcas:\\n relationships.append((lines1[anc], lines2[anc]))\\n return relationships\",\n \"def relationships(self):\",\n \"def de2ue(edges):\\n return set(de for de in edges if tuple(reversed(de)) in edges)\",\n \"def get_synset_pairs(synset: Synset) -> list:\\n # Remove phrasal expressions from the literals\\n literals = remove_phrases(synset.literals)\\n\\n # Generate a list of unique pairs representing the cartesian product of the list of literals of the single synset\\n pairs = unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in literals for w2 in literals if not w1 == w2])\\n return pairs\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def nodesInTuples(setOfTuples):\\n nodesList = []\\n for tupl in setOfTuples:\\n nodesList.extend(tupl)\\n return list(set(nodesList))\",\n \"def get_common_targets(\\n self,\\n sources: List[Tuple[str, str]],\\n relation: str,\\n ) -> List[Node]:\\n rel_str = \\\":%s\\\" % relation if relation else \\\"\\\"\\n parts = [\\n \\\"({id: '%s'})-[%s]->(t)\\\" % (norm_id(*source), rel_str) for source in sources\\n ]\\n query = \\\"\\\"\\\"\\n MATCH %s\\n RETURN DISTINCT t\\n \\\"\\\"\\\" % \\\",\\\".join(\\n parts\\n )\\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\\n return nodes\",\n \"def _pivot_relations(relset, keymap, db):\\n edges = []\\n nodes = set()\\n\\n def add_edges(keys):\\n for i in range(len(keys) - 1):\\n for j in range(i + 1, len(keys)):\\n edges.append((keys[i], keys[j]))\\n\\n for rel in relset:\\n keys = keymap[rel]\\n nodes.update(keys)\\n add_edges(keys)\\n\\n pivots = set()\\n components = util._connected_components(nodes, edges)\\n while len(components) > 1:\\n improved = False\\n for rel, keys in keymap.items():\\n if rel not in relset.union(pivots) and len(keys) > 1:\\n if sum(1 if c.intersection(keys) else 0\\n for c in components) > 1:\\n nodes.update(keys)\\n add_edges(keys)\\n pivots.add(rel)\\n improved = True\\n break\\n if not improved:\\n raise TSQLError('could not find relation to join: {}'\\n .format(', '.join(sorted(relset))))\\n components = util._connected_components(nodes, edges)\\n\\n return pivots\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def _dag_dependents(db: Redis[bytes], dag_of: hash_t, op_from: hash_t) -> set[hash_t]:\\n return __set_as_hashes(\\n db, join(DAG_OPERATIONS, dag_of), join(OPERATIONS, op_from, \\\"children\\\")\\n )\",\n \"def get_edges(self) -> []:\\n graph_edges = []\\n\\n for vertex in self.adj_list:\\n for connection in self.adj_list[vertex]:\\n if (vertex, connection) not in graph_edges and (connection, vertex) not in graph_edges:\\n graph_edges.append((vertex, connection))\\n\\n return graph_edges\",\n \"def relationships(self, r_type=None, n_ids=()):\\n if r_type is None:\\n r_sets = []\\n else:\\n r_sets = [self._relationships_by_type.get(r_type, frozenset())]\\n if not n_ids or (hasattr(n_ids, \\\"__iter__\\\") and all(n_id is None for n_id in n_ids)):\\n pass\\n elif isinstance(n_ids, Sequence):\\n for n_index, n_id in enumerate_nodes(n_ids):\\n if n_id is not None:\\n r_sets.append({r_id for r_id, i in self._relationships_by_node.get(n_id, ())\\n if i == n_index})\\n elif isinstance(n_ids, Set):\\n for n_id in n_ids:\\n if n_id is not None:\\n r_sets.append({r_id for r_id, i in self._relationships_by_node.get(n_id, ())})\\n else:\\n raise TypeError(\\\"Nodes must be supplied as a Sequence or a Set\\\")\\n if r_sets:\\n return iter(reduce(and_operator, r_sets))\\n else:\\n return iter(self._relationships)\",\n \"def matching_graph(n):\\r\\n k_n = nx.complete_graph(n)\\r\\n G = nx.Graph()\\r\\n for i in k_n.edges():\\r\\n G.add_node(i)\\r\\n w = []\\r\\n for i in k_n.edges():\\r\\n for j in k_n.edges():\\r\\n if ((j[0] not in i) and (j[1] not in i) and ((i,j) not in w) and ((j,i) not in w)): \\r\\n w.append((i,j))\\r\\n G.add_edge(i,j)\\r\\n return G\",\n \"def make_nodes_and_paths(friends_lst):\\n\\n # nodes = {}\\n\\n # for item in friends_lst:\\n # friend1, friend2, group = item\\n # for person in pair:\\n # if not nodes.get(person):\\n # nodes[person] = pair[1]\\n\\n # nodes = [{'name': person, 'friend': nodes[person]} for person in nodes.keys()]\\n\\n nodes = {}\\n for item in friends_lst:\\n friend1, friend2, group = item\\n if not nodes.get(friend1):\\n nodes[friend1] = group\\n elif nodes.get(friend1) > group:\\n nodes[friend1] = group\\n\\n nodes = [{'name': person, 'group': nodes[person]} for person in nodes.keys()]\\n\\n index_nodes = {}\\n for idx, n in enumerate(nodes):\\n index_nodes[n['name']] = (idx, n['group'])\\n\\n paths = []\\n\\n # paths.append({'source': item[1], 'target': item[0]})\\n\\n for item in friends_lst:\\n # one = User.query.get(item.user_id)\\n # two = User.query.get(item.friend_id)\\n source, target, group = item\\n paths.append({'source': index_nodes[source][0], 'target': index_nodes[target][0]})\\n\\n # print nodes\\n # print index_nodes\\n # print paths\\n\\n return nodes, paths\",\n \"def get_edges(self):\\n return \\\\\\n set({\\n edge\\n for node in self.nodeset\\n for edge in node.get_incident_edges()\\n })\",\n \"def adjacent_pairs(self, nodes: Tuple[int], k: int) -> List[Tuple[int, int]]:\\n n = len(nodes)\\n return [(u, nodes[j % n])\\n for i, u in enumerate(nodes)\\n for j in range(i + 1, i + 1 + k // 2)]\",\n \"def external_terminologies(self):\\n terms = set()\\n for node_record in self.graph.run(\\\"MATCH (n) RETURN (n)\\\"):\\n node = node_record[\\\"n\\\"]\\n if \\\"links_to\\\" in node:\\n terms.add(node[\\\"links_to\\\"])\\n return terms\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def findAllLiveRelationships(tx):\\n query = (\\n \\\"MATCH (n1:Person)-[r:LIVE]->(n2:House) \\\"\\n \\\"RETURN ID(n1) , r , ID(n2);\\\"\\n )\\n results = tx.run(query).data()\\n return results\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def cooccuranceBlock(ntupleSet,nodeList):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n differentNodes = set(v).difference(set([a]))\\n NumberdifferentNodes = len(differentNodes) \\n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\\n \\n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))\",\n \"def get_dependencies(graph: Graph, node: Node):\\n dependencies: Set[Node] = set()\\n def traverse_nodes(nodes):\\n for candidate in nodes:\\n if candidate not in dependencies:\\n dependencies.add(candidate)\\n traverse_nodes(graph[candidate])\\n traverse_nodes(graph[node])\\n dependencies.discard(node)\\n return dependencies\",\n \"def _find_relations(self, node, depth=0):\\n depth += 1\\n\\n model = node.model\\n opts = model._meta\\n\\n # determine relational fields to determine paths\\n forward_fields = opts.fields\\n reverse_fields = opts.get_all_related_objects()\\n\\n forward_o2o = filter(self._filter_one2one, forward_fields)\\n reverse_o2o = filter(self._filter_related_one2one, reverse_fields)\\n\\n forward_fk = filter(self._filter_fk, forward_fields)\\n reverse_fk = filter(self._filter_related_fk, reverse_fields)\\n\\n forward_m2m = filter(self._filter_m2m, opts.many_to_many)\\n reverse_m2m = filter(self._filter_related_m2m,\\n opts.get_all_related_many_to_many_objects())\\n\\n # iterate m2m relations\\n for f in forward_m2m:\\n kwargs = {\\n 'parent': node,\\n 'model': f.rel.to,\\n 'relation': 'manytomany',\\n 'reverse': False,\\n 'related_name': f.name,\\n 'accessor_name': f.name,\\n 'nullable': True,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n # iterate over related m2m fields\\n for r in reverse_m2m:\\n kwargs = {\\n 'parent': node,\\n 'model': r.model,\\n 'relation': 'manytomany',\\n 'reverse': True,\\n 'related_name': r.field.related_query_name(),\\n 'accessor_name': r.get_accessor_name(),\\n 'nullable': True,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n # iterate over one2one fields\\n for f in forward_o2o:\\n kwargs = {\\n 'parent': node,\\n 'model': f.rel.to,\\n 'relation': 'onetoone',\\n 'reverse': False,\\n 'related_name': f.name,\\n 'accessor_name': f.name,\\n 'nullable': False,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n # iterate over related one2one fields\\n for r in reverse_o2o:\\n kwargs = {\\n 'parent': node,\\n 'model': r.model,\\n 'relation': 'onetoone',\\n 'reverse': True,\\n 'related_name': r.field.related_query_name(),\\n 'accessor_name': r.get_accessor_name(),\\n 'nullable': False,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n # iterate over fk fields\\n for f in forward_fk:\\n kwargs = {\\n 'parent': node,\\n 'model': f.rel.to,\\n 'relation': 'foreignkey',\\n 'reverse': False,\\n 'related_name': f.name,\\n 'accessor_name': f.name,\\n 'nullable': f.null,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n # iterate over related foreign keys\\n for r in reverse_fk:\\n kwargs = {\\n 'parent': node,\\n 'model': r.model,\\n 'relation': 'foreignkey',\\n 'reverse': True,\\n 'related_name': r.field.related_query_name(),\\n 'accessor_name': r.get_accessor_name(),\\n 'nullable': True,\\n 'depth': depth,\\n }\\n self._add_node(**kwargs)\\n\\n return node\",\n \"def find_relations(self, rid:int, *rids):\\n first = set(self.rid_to_relations.get(rid, ()))\\n if rids:\\n return first.intersection(*[self.rid_to_relations.get(x, set()) for x in rids])\\n return first\",\n \"def connected_components(nodes):\\n\\n # List of connected components found. The order is random.\\n result = []\\n\\n # Make a copy of the set, so we can modify it.\\n nodes = set(nodes)\\n\\n # Iterate while we still have nodes to process.\\n while nodes:\\n\\n # Get a random node and remove it from the global set.\\n n = nodes.pop()\\n\\n # This set will contain the next group of nodes\\n # connected to each other.\\n group = {n}\\n\\n # Build a queue with this node in it.\\n queue = [n]\\n\\n # Iterate the queue.\\n # When it's empty, we finished visiting a group of connected nodes.\\n while queue:\\n\\n # Consume the next item from the queue.\\n n = queue.pop(0)\\n\\n # Fetch the neighbors.\\n neighbors = n.links\\n\\n # Remove the neighbors we already visited.\\n neighbors.difference_update(group)\\n\\n # Remove the remaining nodes from the global set.\\n nodes.difference_update(neighbors)\\n\\n # Add them to the group of connected nodes.\\n group.update(neighbors)\\n\\n # Add them to the queue, so we visit them in the next iterations.\\n queue.extend(neighbors)\\n\\n # Add the group to the list of groups.\\n result.append(group)\\n\\n # Return the list of groups.\\n return result\",\n \"def common_dependency_targets(graph1, graph2, n1, n2, node_attrib='label',\\n edge_attrib='label'):\\n n1_children = dependency_children(graph1, n1, edge_attrib=edge_attrib)\\n n2_children = dependency_children(graph2, n2, edge_attrib=edge_attrib)\\n n1_rels, n2_rels = defaultdict(list), defaultdict(list)\\n\\n for source_set, target_dict in ((n1_children, n1_rels), (n2_children, n2_rels)):\\n for rel, target in source_set:\\n target_dict[rel].append(target)\\n\\n common_rels = set(n1_rels) & set(n2_rels) # intersection\\n common_deps = set()\\n for rel in common_rels:\\n for n1_target in n1_rels[rel]:\\n n1_target_word = graph1.node[n1_target][node_attrib]\\n for n2_target in n2_rels[rel]:\\n n2_target_word = graph2.node[n2_target][node_attrib]\\n if n1_target_word == n2_target_word:\\n common_deps.add( (n1_target, n2_target) )\\n return common_deps\",\n \"def get_other_neighbors(self, node):\\n neighbors = self.get_neighbors()\\n return list(set(neighbors) - set([node]))\",\n \"def get_connected_nodes(self, adj_keys: Publication, node_id: str) -> Set[str]:\\n import networkx as nx\\n\\n edges = set()\\n graph = nx.Graph()\\n for adj_value in adj_keys.keyVals.values():\\n if adj_value.value:\\n adj_db = deserialize(openr_types.AdjacencyDatabase, adj_value.value)\\n else:\\n adj_db = openr_types.AdjacencyDatabase()\\n graph.add_node(adj_db.thisNodeName)\\n for adj in adj_db.adjacencies:\\n # Add edge only when we see the reverse side of it.\\n if (adj.otherNodeName, adj_db.thisNodeName, adj.otherIfName) in edges:\\n graph.add_edge(adj.otherNodeName, adj_db.thisNodeName)\\n continue\\n edges.add((adj_db.thisNodeName, adj.otherNodeName, adj.ifName))\\n # pyre-ignore[16]\\n return nx.node_connected_component(graph, node_id)\",\n \"def find_independent(self) -> list:\\n results = list() # our results list that\\n for node in self.network:\\n # Checks if the dependencies actually doesnt exist\\n if (node.get_dependencies() in [None, list(), tuple(), set()]):\\n results.append(node)\\n return results\",\n \"def find_connected_links(self, node):\\n connected_link_set = []\\n if node in self.outgoing_links:\\n for links in self.outgoing_links[node].values():\\n connected_link_set.extend(links)\\n \\n if node in self.incoming_links:\\n for links in self.incoming_links[node].values():\\n connected_link_set.extend(links)\\n \\n return connected_link_set\",\n \"def likely_pairs(self, k=2):\\n for a in self.G.nodes():\\n if not self.eligible_node(a):\\n continue\\n for b in neighbourhood(self.G, a, k):\\n if not self.eligible_node(b):\\n continue\\n yield (a, b)\",\n \"def joint_graph(graph, nodes):\\n # TODO\\n joint_graph = nodes = None\\n\\n return joint_graph, nodes\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def get_edges(self):\\n return_set = set()\\n for outer_index, outer_list in enumerate(self._adjmatrix):\\n for inner_index, inner_item in enumerate(outer_list):\\n if(inner_item):\\n return_set.add(\\n (self._name[outer_index],\\n self._name[inner_index]))\\n return return_set\",\n \"def get_edge_ids(self):\\n node_ids = self.node_ids\\n return [(node_ids[0], node_ids[1])]\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({neighbour, vertex})\\n return edges\",\n \"def read_nell_relations():\\n\\trel=os.walk(\\\"nell/relations\\\")\\n\\trelation=[]\\n\\tfor i in rel:\\n\\t\\ttrel=i[2]\\n\\tfor i in trel:\\n\\t\\trelation.append(' '.join(segment(i.split(':')[1])))\\n\\treturn relation\",\n \"def neighbors(node, test_set):\\r\\n result = set()\\r\\n for neighbor in node.neighbors:\\r\\n if neighbor in test_set:\\r\\n result.add(neighbor)\\r\\n return result\",\n \"def count_unique_relations(graph):\\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.70479345","0.6927845","0.6710669","0.6699805","0.6634587","0.65720505","0.6555457","0.65286154","0.6481142","0.6458834","0.64464796","0.63734806","0.6327714","0.6283819","0.6210741","0.6195693","0.61790866","0.61713094","0.616871","0.61438185","0.61343056","0.6131738","0.61086667","0.609211","0.60590017","0.60409886","0.6037984","0.6003341","0.59834516","0.5961397","0.5940724","0.59370744","0.59239745","0.5920151","0.5876532","0.5868771","0.5861234","0.5844816","0.58394504","0.5825208","0.58192635","0.5812005","0.5799264","0.5784608","0.57840234","0.5775085","0.5773077","0.575906","0.57558405","0.57549864","0.5745207","0.57431483","0.57412463","0.5736688","0.5735331","0.57353145","0.5728168","0.5726446","0.5718023","0.57061857","0.57048965","0.57047","0.56869495","0.56766903","0.56725484","0.56513196","0.5649001","0.5639261","0.56387144","0.56383234","0.5632338","0.5630434","0.5629472","0.5628759","0.56195366","0.5617343","0.5613207","0.5598875","0.5594671","0.5588838","0.5585215","0.55802083","0.5571283","0.55712456","0.5570413","0.5566455","0.55581856","0.55557185","0.55479294","0.55422306","0.5536377","0.55304354","0.5527568","0.5521024","0.55188316","0.55187166","0.55175984","0.55145794","0.55097663","0.55086446"],"string":"[\n \"0.70479345\",\n \"0.6927845\",\n \"0.6710669\",\n \"0.6699805\",\n \"0.6634587\",\n \"0.65720505\",\n \"0.6555457\",\n \"0.65286154\",\n \"0.6481142\",\n \"0.6458834\",\n \"0.64464796\",\n \"0.63734806\",\n \"0.6327714\",\n \"0.6283819\",\n \"0.6210741\",\n \"0.6195693\",\n \"0.61790866\",\n \"0.61713094\",\n \"0.616871\",\n \"0.61438185\",\n \"0.61343056\",\n \"0.6131738\",\n \"0.61086667\",\n \"0.609211\",\n \"0.60590017\",\n \"0.60409886\",\n \"0.6037984\",\n \"0.6003341\",\n \"0.59834516\",\n \"0.5961397\",\n \"0.5940724\",\n \"0.59370744\",\n \"0.59239745\",\n \"0.5920151\",\n \"0.5876532\",\n \"0.5868771\",\n \"0.5861234\",\n \"0.5844816\",\n \"0.58394504\",\n \"0.5825208\",\n \"0.58192635\",\n \"0.5812005\",\n \"0.5799264\",\n \"0.5784608\",\n \"0.57840234\",\n \"0.5775085\",\n \"0.5773077\",\n \"0.575906\",\n \"0.57558405\",\n \"0.57549864\",\n \"0.5745207\",\n \"0.57431483\",\n \"0.57412463\",\n \"0.5736688\",\n \"0.5735331\",\n \"0.57353145\",\n \"0.5728168\",\n \"0.5726446\",\n \"0.5718023\",\n \"0.57061857\",\n \"0.57048965\",\n \"0.57047\",\n \"0.56869495\",\n \"0.56766903\",\n \"0.56725484\",\n \"0.56513196\",\n \"0.5649001\",\n \"0.5639261\",\n \"0.56387144\",\n \"0.56383234\",\n \"0.5632338\",\n \"0.5630434\",\n \"0.5629472\",\n \"0.5628759\",\n \"0.56195366\",\n \"0.5617343\",\n \"0.5613207\",\n \"0.5598875\",\n \"0.5594671\",\n \"0.5588838\",\n \"0.5585215\",\n \"0.55802083\",\n \"0.5571283\",\n \"0.55712456\",\n \"0.5570413\",\n \"0.5566455\",\n \"0.55581856\",\n \"0.55557185\",\n \"0.55479294\",\n \"0.55422306\",\n \"0.5536377\",\n \"0.55304354\",\n \"0.5527568\",\n \"0.5521024\",\n \"0.55188316\",\n \"0.55187166\",\n \"0.55175984\",\n \"0.55145794\",\n \"0.55097663\",\n \"0.55086446\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6073819"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":20169,"cells":{"query":{"kind":"string","value":"Returns if the edges between the given nodes are consistent, meaning they all have the same relation"},"document":{"kind":"string","value":"def pair_is_consistent(graph, u, v):\n relations = get_all_relations(graph, u, v)\n\n if 1 != len(relations):\n return False\n\n return list(relations)[0]"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def __has_multiple_edges(self):\n return \\\n len(\n list(\n [\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n ] # the length of the list which allows duplicates...\n )\n ) != \\\n len(\n set(\n {\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n } # ...should equal the length of the set that does not allow duplicates\n )\n ) # return True if the two data structures are equal in size and False otherwise","def graph_is_connected(node_count, edges):\n\n disjoint_set = disjoint.DisjointSet(node_count + 1)\n\n for a, b in edges:\n disjoint_set.union(a, b)\n\n # Check if all nodes are part of the same set\n\n root = disjoint_set.root(1)\n\n for i in range(2, node_count + 1):\n if disjoint_set.root(i) != root:\n return False\n\n return True","def check_regularity(edges):\n for a, b in edges:\n counter_a = 0\n counter_b = 0\n for x, y in edges:\n if a == x or a == y:\n counter_a += 1\n if b == x or b == y:\n counter_b += 1\n assert (counter_a > 0) and (counter_b > 0)\n if (counter_a == 1) or (counter_b == 1):\n raise Exception(\"Boundary is not closed.\")\n if (counter_a > 2) or (counter_b > 2):\n raise Exception(\"More than two edges share a node.\")","def nodes_are_interconnected(graph, nodes):\n \n nid_list = []\n for node in nodes:\n if hasattr(node, 'nid'):\n nid_list.append(node.nid)\n elif node in graph.nodes:\n nid_list.append(node)\n else:\n raise 'Node not in graph {0}'.format(node)\n\n nid_list = set(nid_list)\n\n collection = []\n for nid in nid_list:\n query = set(graph.adjacency[nid] + [nid])\n collection.append(query.intersection(nid_list) == nid_list)\n \n return all(collection)","def any_edges_intersect(nodes, edges):\n for i in range(len(edges)):\n for j in range(i+1, len(edges)):\n e1 = edges[i]\n e2 = edges[j]\n if e1[1] == e2[0] or e1[0] == e2[1]:\n continue\n if two_edges_intersect(nodes, e1, e2):\n return True\n return False","def haveNoSameEdges(seg1,seg2,segmentsMeta):\n seg1Edges = segmentsMeta['edges'][seg1]\n seg2Edges = segmentsMeta['edges'][seg2]\n return not any(a==b for a in seg1Edges for b in seg2Edges)","def graph_has_self_loops(edges):\n\n for a, b in edges:\n if a == b:\n return True\n\n return False","def has_cycle(graph):\n ds = DisjointSet()\n\n # creates a set of all graph nodes\n node_set = set()\n for edge in graph:\n node_set.add(edge.node1)\n node_set.add(edge.node2)\n\n for item in node_set:\n ds.make_set(item)\n\n for edge in graph:\n same_set = ds.union(edge.node1, edge.node2)\n if same_set:\n return True\n\n return False","def CompareEdges(self,edge,dict):\n \"\"\"Does not assume symmetric edge lists, though you should probably have them\"\"\"\n # Edge is a tuple with two nodes\n # Dict is a dictionary of node-keys and tuple (node,float) values\n if edge[0] in dict.keys():\n if edge[1] in [x[0] for x in dict[edge[0]]]:\n return True\n else:\n return False\n else:\n if edge[1] in dict.keys():\n if edge[0] in [x[0] for x in dict[edge[1]]]:\n return True\n else:\n return False\n else:\n return False","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def edge_intersects_edges(e1, nodes, edges):\n for i in range(len(edges)):\n e2 = edges[i]\n if e1[1] == e2[0] or e1[0] == e2[1]:\n continue\n if two_edges_intersect(nodes, e1, e2):\n return True\n return False","def are_connected(self, node1, node2):\n return bool( self.get_edge(node1, node2) )","def has_multiple_edges(self):\n # Create a list of edge 2-tuples (a, b)\n edge_tuples = [(e['from_id'], e['to_id']) for e in self._edges]\n if len(edge_tuples) > len(set(edge_tuples)): # Do 'real' multiple edges exist?\n return True\n\n # Create a list of edge 2-tuples (a, b) with a <= b\n edge_tuples = [(min(e['from_id'], e['to_id']), max(e['from_id'], e['to_id'])) for e in self._edges]\n edge_tuples_set = set(edge_tuples)\n\n if len(edge_tuples) == 2 * len(edge_tuples_set): # This only happens if for each edge (a, b) also (b, a) exists\n return False\n else:\n # The set kicks out duplicate edges => less edges in the set means there were multiple edges\n return len(edge_tuples) > len(edge_tuples_set)","def is_connected_same_node(graph, node_u, node_v):\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\n if out_neighbor_u == out_neighbor_v:\n return True\n return False","def __has_conflicting_node_names(self):\n # check length of sets to determine if overlap exists\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())","def consistency(node, sequence, orientation, overlap):\n from_id, to_id = node\n from_sequence, to_sequence = sequence\n from_orn, to_orn = orientation\n if from_orn == '-':\n from_sequence = reverse_and_complement(from_sequence)\n if to_orn == '-':\n to_sequence = reverse_and_complement(to_sequence)\n size_overlap = real_overlap(from_sequence, to_sequence)\n if not size_overlap == overlap:\n GRAPH_LOGGER.debug('Edge between node %s and %s have \\\n \tno consistency between CIGAR overlap end \"real\" overlap', from_id, to_id)\n return False\n\n return True","def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v","def is_consistent(graph, goal):\n\n consistent = True\n\n for edge in graph.edges:\n consistent &= edge.length >= abs(\n graph.get_heuristic(edge.node1, goal) -\n graph.get_heuristic(edge.node2, goal)\n )\n\n if not consistent:\n break\n\n return consistent","def test_same_node_is_reachable(self):\n # G is an arbitrary tournament on ten nodes.\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\n assert_true(all(is_reachable(G, v, v) for v in G))","def _degree_has_changed(first, second):\n return len(set(first) ^ set(second)) != 0","def is_connected(self, node1, node2):\r\n\r\n return node1 in self.graph and node2 in self.graph[node1]","def consistent(h, phi):\n for n in h: # for each node in h\n if phi(n) in h and phi(n) not in h:\n return False\n return True","def test_consistent_ids(self) -> None:\n bnode = BNode()\n g0_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Golan Trevize\")),\n (bnode, RDF.type, FOAF.Person),\n }\n bnode = BNode()\n g1_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Janov Pelorat\")),\n (bnode, RDF.type, FOAF.Person),\n }\n\n g0 = Graph()\n g0 += g0_ts\n cg0 = to_canonical_graph(g0)\n cg0_ts = GraphHelper.triple_set(cg0)\n\n g1 = Graph()\n g1 += g1_ts\n cg1 = to_canonical_graph(g1)\n cg1_ts = GraphHelper.triple_set(cg1)\n\n assert cg0_ts.issubset(\n cg1_ts\n ), \"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\"","def graph_has_duplicates(edges, is_bidirectional=True):\n\n curr_edges = set()\n\n for edge in edges:\n if is_bidirectional and edge[0] > edge[1]:\n edge = (edge[1], edge[0])\n\n if edge in curr_edges:\n return True\n else:\n curr_edges.add(edge)\n\n return False","def test_edges(self):\n\n edge_list = self.g.edges()\n self.assertEqual(42, len(edge_list))\n\n # p1 p3 and p3 p1 are valid edges\n t1 = ('p1', 'p3')\n self.assertTrue(t1 in edge_list)\n\n t2 = ('p3', 'p1')\n self.assertTrue(t2 in edge_list)\n\n made_up = ('z1', 'q123')\n self.assertFalse(made_up in edge_list)\n\n return None","def num_edges(graph1: list, graph2: list):\n check1 = 0\n check2 = 0\n for row, _ in enumerate(graph1):\n for column, _ in enumerate(graph1[row]):\n if graph1[row][column] == 1:\n check1 += 1\n if graph2[row][column] == 1:\n check2 += 1\n return check1 == check2","def is_independent_set(G, nodes):\n nodes = set(nodes)\n if not nodes.issubset(G):\n raise nx.NetworkXUnfeasible(\n \"%s is not a subset of the nodes of G\" % nodes)\n neighbors = []\n [neighbors.extend( G.neighbors(v) ) for v in nodes]\n neighbors = set(neighbors)\n if set.intersection(neighbors, nodes):\n return False;\n else:\n return True;","def check(self, expected, debug=True):\r\n for v1, v2, go in expected:\r\n for gj, oj in go:\r\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\r\n assert r1 == oj\r\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\r\n assert r2 == oj","def is_connected(self, node1, node2):\r\n\r\n return node1 in self._graph and node2 in self._graph[node1]","def check_duplicate_schema(schema_edges, node_list):\n # checking for duplicates amounts to checking the min difference between any two nodes being greater than 1\n differences = []\n for node in node_list:\n min_diff = sys.maxsize\n for node2 in node_list:\n if node == node2:\n continue\n diff = abs(node - node2)\n if diff < min_diff:\n min_diff = diff\n differences.append(min_diff)\n # all differences should be 1 if this chain is not a duplicate\n return any(difference != 1 for difference in differences)","def __eq__(self, other):\n if not type(other) == type(self):\n return False\n sedges, oedges = self.edges, other.edges\n return ((len(sedges) == len(oedges)) and\n all(numpy.all(se == oe) for (se, oe) in zip(sedges, oedges)))","def consistent(self, assignment):\n for node1 in assignment:\n for node2 in assignment:\n\n if node1 != node2:\n #returns False if any assignmed words are the same\n if assignment[node1] == assignment[node2]:\n return False\n\n overlap= self.crossword.overlaps[node1,node2]\n if overlap != None:\n #checks if words assigned to node overlaps are the same letter\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\n return False\n\n return True","def test_if_nodes_are_in_same_chunk(self, node_ids: Sequence[np.uint64]\n ) -> bool:\n assert len(node_ids) == 2\n return self.get_chunk_id(node_id=node_ids[0]) == \\\n self.get_chunk_id(node_id=node_ids[1])","def compare(self, node) -> bool:\n\t\t# No conflicts, Return True\n\t\treturn True","def same_edge(self, other, precision=0):\n return self.id == other.id \\\n and self.start_node == other.start_node \\\n and self.end_node == other.end_node \\\n and abs(self.cost - other.cost) <= precision \\\n and abs(self.reverse_cost - other.reverse_cost) <= precision \\\n and self.reversed == other.reversed","def check_undirected(graph):\n for node in graph:\n for neighbor in graph[node]:\n if node not in graph[neighbor]:\n return False\n return True","def contains_edge(self, node, other_node):\n return \\\n {node.get_name(), other_node.get_name()} in \\\n list([\n {edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()}\n for edge in self.get_edges()\n ]) # return true if there exists an edge between the input nodes and false otherwise","def is_all_visited(self):\n cond = [node.visited if node and node.belongs and node.valid else True for node in self.nodes.flatten()]\n return all(cond)","def is_graph_isomorphic(self):\n out=True\n for node in self.node_names:\n self.move_to_node(node)\n if not self.check_closed_path:\n out=False\n return out","def perms_are_connected(g, n):\n from sage.graphs.graph import Graph\n G = Graph()\n if g:\n G.add_vertices(g[0].domain())\n for p in g:\n G.add_edges(p.dict().items())\n return G.is_connected()","def test_nodes_exist(graph_no_edges):\n for node in graph_no_edges:\n assert graph_no_edges.has_node(node)","def is_edge_connected_dfs(adj_dict, vertex, edges, check, check_edges):\n check[vertex] = True\n length = len(edges)\n for vert, weigth in adj_dict[vertex]:\n for i in range(length):\n a, b, c = edges[i]\n if (a == vertex and b == vert and c == weigth):\n check_edges[i] = True\n elif (a == vert and b == vertex and c == weigth):\n check_edges[i] = True\n if not check[vert]:\n is_edge_connected_dfs(adj_dict, vert, edges, check, check_edges)","def _vertices_are_equal(\n vertices1: List[np.ndarray], vertices2: List[np.ndarray]\n) -> bool:\n if len(vertices1) != len(vertices2):\n return False\n diff = vertices1 - vertices2\n if np.abs(np.max(diff)) < ways_are_equal_tolerance:\n return True\n return False","def is_edge_connected(num_vertices, adj_dict, edges):\n if not num_vertices or not adj_dict:\n return True\n check = { i:False for i in adj_dict.keys() }\n check_edges = [False for _ in range(len(edges))]\n first_vertex = list(adj_dict.keys())[0]\n is_edge_connected_dfs(adj_dict, first_vertex, edges, check, check_edges)\n return not False in check_edges","def isEquivalent(self, oth: 'StateNode') -> bool:\n a = [self.table[i][j] for i in self.state[0] for j in self.state[1]]\n b = [oth.table[i][j] for i in oth.state[0] for j in oth.state[1]]\n if len(a) != len(b):\n return False\n if len(a) < 1 or len(b) < 1 or len(a[0]) != len(b[0]):\n return False\n for i in range(len(a)):\n for j in range(len(a[0])):\n if a[i][j] != b[i][j]:\n return False\n return True","def permissible(e1, e2):\n return e1[1] == e2[0] and \\\n total_edge_length(e1, e2) < maximum_distance and \\\n total_edge_angle(e1, e2) < maximum_angle_delta","def similar(g1, g2):\r\n return all(t1 == t2 for (t1, t2) in _squashed_graphs_triples(g1, g2))","def is_directed(G):\n return G.is_directed()","def are_connected(self, person1, person2):\n\n possible_nodes = Queue()\n seen = set()\n possible_nodes.enqueue(person1)\n seen.add(person1)\n\n while not possible_nodes.is_empty():\n person = possible_nodes.dequeue()\n print(\"checking\", person)\n if person is person2:\n return True\n else:\n for cohabitant in person.adjacent - seen:\n possible_nodes.enqueue(cohabitant)\n seen.add(cohabitant)\n print(\"added to queue:\", cohabitant)\n return False","def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\n logger.debug(f\"checking symmtrical connections for nodes: {node1}, {node2}\")\n tree1 = set(get_next_level(G,[node1]))\n tree2 = set(get_next_level(G,[node2]))\n traversed1.append(node1)\n traversed2.append(node2)\n if tree1==tree2:\n return True\n while(len(list(tree1))== len(list(tree2)) > 0):\n logger.debug(f\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\")\n tree1 = set(tree1) - set(traversed1)\n tree2 = set(tree2) - set(traversed2)\n\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\n return True\n else:\n traversed1+=list(tree1)\n traversed2+=list(tree2)\n tree1=set(get_next_level(G,tree1))\n tree2=set(get_next_level(G,tree2))\n\n logger.debug(f\"Non symmetrical branches for nets: {node1}, {node2}\")\n return False","def compare_nodes(n1, n2):\n return n1['g_val'] + n1['h_val'] < n2['g_val'] + n2['h_val']","def cycle_check(node):\n node_marker1 = node_marker2 = node\n\n while node_marker2 and node_marker2.nextnode:\n node_marker1 = node_marker1.nextnode # node_marker1 runs 1 node at each step\n node_marker2 = node_marker2.nextnode.nextnode # node_marker2 runs 2 node at each step\n if node_marker1 == node_marker2:\n return True # meaning that they are meeting each other at some point because of linked list is cycle.\n # End of while\n return False","def edges_is_closed_curve(edges):\n e_prev = first = edges[0]\n for e in edges[1:]:\n if e_prev[1] != e[0]:\n if e_prev[1] == first[0]:\n # new loop\n first = e\n else:\n return False\n e_prev = e\n if e_prev[1] != first[0]:\n return False\n return True","def equivalent(kls, first, second):\n if first.empty() and second.empty():\n return True\n elif first.vertices.shape[0] != second.vertices.shape[0]:\n return False\n elif first.edges.shape[0] != second.edges.shape[0]:\n return False\n\n EPSILON = 1e-7\n\n vertex1, ct1 = np.unique(first.vertices, axis=0, return_counts=True)\n vertex2, ct2 = np.unique(second.vertices, axis=0, return_counts=True)\n \n vertex_match = np.all(np.abs(vertex1 - vertex2) < EPSILON)\n ct_match = np.all(ct1 == ct2)\n if not (vertex_match and ct_match):\n return False\n\n g1 = nx.Graph()\n g1.add_edges_from(first.edges)\n g2 = nx.Graph()\n g2.add_edges_from(second.edges)\n edges_match = nx.is_isomorphic(g1, g2)\n del g1 \n del g2\n\n if not edges_match:\n return False\n\n second_verts = {}\n for i, vert in enumerate(second.vertices):\n second_verts[tuple(vert)] = i\n \n attrs = [ attr['id'] for attr in first.extra_attributes ]\n for attr in attrs:\n buf1 = getattr(first, attr)\n buf2 = getattr(second, attr)\n if len(buf1) != len(buf2):\n return False\n\n for i in range(len(buf1)):\n i2 = second_verts[tuple(first.vertices[i])]\n if buf1[i] != buf2[i2]:\n return False\n\n return True","def has_consistent_orientation(triangles):\n num_triangles = len(triangles)\n for tri_idx in range(num_triangles):\n for edge in range(3):\n if not has_same_edge_orientation(triangles, tri_idx, edge):\n return False\n return True","def connected(self, x, y):\n\n return self.__find_root(x) == self.__find_root(y)","def has_relationship(self, source_node: Node, target_node: Node) -> bool: # pylint: disable=no-self-use\n return source_node.node_id in target_node.in_nodes_ids","def is_directed(self):\n return self._incoming is not self._outgoing\n # directed if maps are distinct","def IsEulerGraph(self):\n\n for node in self.nodes:\n if ((len(node.neighbours) % 2) == 1) or (len(node.neighbours) == 0):\n return False\n return True","def isSameState(self, oth: 'StateNode') -> bool:\n def sameElements(a: list, b: list):\n return len([1 for i, j in zip(a, b) if i == j]) == len(a) and len(a) == len(b)\n if self.table != oth.table:\n return False\n a_lin, a_col = self.state\n b_lin, b_col = oth.state\n return sameElements(a_lin, b_lin) and sameElements(a_col, b_col)","def _check_consistency(self, item, path, targets):\n for neighbor in self._edges[path[-1]]:\n if neighbor in path:\n continue\n elif self._nodes[neighbor][item] in (EMPTY, VISITED):\n continue\n\n remaining = set(targets)\n if neighbor in targets:\n remaining.remove(neighbor)\n if len(remaining) == 0:\n return True\n\n if self._check_consistency(item, path + [neighbor], remaining):\n return True\n\n return False","def check_adjacency(layer_a, layer_b, topology):\n adjacency = None\n for node in topology.graph.node.keys():\n if layer_a in node:\n # print topology.graph.edge[node].keys()\n for edge in topology.graph.edge[node].keys():\n if layer_b in edge:\n # print topology.graph.edge[node][edge]\n # print \"Node \",layerA,\" and \",layerB,\" share an edge!\"\n adjacency = True\n if adjacency is True:\n return True\n else:\n return False","def test_case7(self):\n\n graph3 = self.graph1.merge(self.graph2)\n\n expected = {'supervisor1':['student1','student2','student4'],'supervisor2':['student4','student1','student3'],'supervisor3':['student3','student2']}\n\n result = True\n\n for sup in expected:\n for stu in expected[sup]:\n if not graph3.isEdge(sup,stu):\n result = False\n break\n\n self.assertTrue(result)","def are_the_same(node_before, node_after) -> bool:\n\n if node_before.algorithm != node_after.algorithm:\n return False\n elif not _is_output_name_same(node_before, node_after):\n return False\n else:\n for attr in interested_attrs:\n if _exists_attr(attr, node_before, node_after) == 1 or \\\n _exists_attr(attr, node_before, node_after) == 2:\n return False\n elif _exists_attr(attr, node_before, node_after) == 12 and \\\n node_before.attributes[attr] != node_after.attributes[attr]:\n return False\n return True","def nodes_are_equal(node1, node2):\n\n try:\n return dump_ast(node1).strip() == dump_ast(node2).strip() and \\\n node1.lineno == node2.lineno and \\\n node1.col_offset == node2.col_offset\n except:\n return False","def check_connected(self, update=True):\n # update if needed\n if update:\n\n self.update_neighbors()\n\n # go through each node checking that each degree id greater than 0\n for node in self.nodes:\n\n # only one node needs to be disconnected to fail\n if len(self.nodes[node].neighbors) < 1:\n return False\n\n return True","def is_weakly_connected(G):\n if len(G) == 0:\n raise nx.NetworkXPointlessConcept(\n \"\"\"Connectivity is undefined for the null graph.\"\"\")\n\n return len(list(weakly_connected_components(G))[0]) == len(G)","def is_connected(graph):\n return nx.is_connected(graph.graph)","def is_connected(self):\n vs = self.vertices()\n visited = self.bfs(vs[0])\n return len(visited) == len(vs)","def valid_chain(chain):\n\n for i in range(len(chain) - 1):\n parent_edge = chain[i]\n child_edge = chain[i + 1]\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\n if not parent_edge[1] == child_edge[0]:\n # if this isn't\n return False\n return True","def is_connected(self):\n if self.V < 1:\n raise ValueError(\"empty graph\")\n if self.V < 2:\n return True\n if self.E == 0:\n return False\n cc = self.cc()\n return int(cc.max() == 0)","def consistent(self):\n return all((constraint.consistent() for constraint in self.constraints))","def is_equivalence(self) -> bool:","def is_connected(object_one, object_two):\n\n for vert_one in object_one.Vertexes:\n for vert_two in object_two.Vertexes:\n if (vert_one.X == vert_two.X) and (vert_one.y == vert_two.y):\n return True\n\n return False","def test_case21(self):\n\n result= self.graph1.isEdge(\"supervisor2\",\"student1\")\n\n self.assertFalse(result)","def is_directed(self) -> bool:\n return True","def is_connected(self):\n \n # All the vertices in the graph\n vertices = set(self.vertices())\n \n # Take a random vertex to start the search from\n vertex_search_start = self._edges.keys()[0]\n vertices_found = set(self.DFS(vertex_search_start))\n \n return vertices == vertices_found","def is_cyclic(self):\n \n visited = set()\n path = []\n \n for node in self.node_set:\n if node not in visited:\n if self.is_cyclic_helper(node, visited, path) is True:\n return True \n \n visited.clear()\n path.clear()\n return False","def is_acyclic(graph):\n visited = []\n dfs_seq = DFSIterator(graph)\n\n for node in dfs_seq:\n visited.insert(0, node)\n node_neighbors = graph.get_neighbors(node)\n \n for neighbor in node_neighbors:\n if neighbor in visited:\n return False\n\n return True","def _semantic_feasibility(self, G1_node, G2_node):\n # Make sure the nodes match\n if self.node_match is not None:\n\n nm = self.node_match(G1_node, G2_node)\n if not nm:\n return False\n\n # Make sure the edges match\n if self.edge_match is not None:\n\n # Cached lookups\n G1_adj = self.G1_adj\n G2_adj = self.G2_adj\n core_1 = self.core_1\n edge_match = self.edge_match\n\n for neighbor in G1_adj[G1_node]:\n # G1_node is not in core_1, so we must handle R_self separately\n if neighbor == G1_node:\n if not edge_match(G1_adj[G1_node][G1_node],\n G2_adj[G2_node][G2_node]):\n return False\n elif neighbor in core_1:\n if not edge_match(G1_adj[G1_node][neighbor],\n G2_adj[G2_node][core_1[neighbor]]):\n return False\n # syntactic check has already verified that neighbors are symmetric\n\n return True","def has_edge(self, i: Node, j: Node) -> bool:\n return frozenset({i, j}) in self._edges","def isValidCompatible(cls,root):\n valid = True\n # the order of node types in chains is restricted\n # (this would be easier if the data was in a Corpus-instance)\n allowed = NX.XDiGraph(selfloops=True)\n\n # continue from here!\n allowed.add_edge('Physical','Physical')\n allowed.add_edge('Property','Physical')\n allowed.add_edge('Process','Physical')\n allowed.add_edge('Regulation','Physical')\n\n allowed.add_edge('Property','Property')\n allowed.add_edge('Process','Property')\n allowed.add_edge('Regulation','Property')\n\n allowed.add_edge('Property','Process')\n# allowed.add_edge('Process','Process')\n allowed.add_edge('Regulation','Process')\n\n allowed.add_edge('Property','Regulation')\n# allowed.add_edge('Process','Regulation')\n allowed.add_edge('Regulation','Regulation')\n\n mapping = {}\n for a in root.find(\"ontologies\").findall(\"ontology\"):\n if a.attrib['id']=='interaction':\n for x in a.getiterator(\"ontnode\"):\n if x.attrib.has_key('effect') and x.attrib['effect'].endswith('regulation'):\n t = 'Regulation'\n else:\n t = x.attrib['onttype']\n mapping[x.attrib['id']] = t\n \n for a in root.getiterator(\"relannotation\"):\n t2type = dict( [(x.attrib['id'],x.attrib['type'])\n for x in a.findall(\"reltoken\")] )\n n2t = dict( [(x.attrib['id'],x.attrib['token'])\n for x in a.findall(\"relnode\")] )\n for x in a.findall(\"reledge\"):\n bt = t2type[n2t[x.attrib['bgn']]]\n et = t2type[n2t[x.attrib['end']]]\n bgn = mapping[bt]\n end = mapping[et]\n if not allowed.has_edge(bgn,end):\n printError(cls,inspect.stack()[1][3],\n \"%s -- %s (%s) -> %s (%s) is not a valid edge\"%\n (x.attrib['id'].split('.')[1],bgn,bt,end,et))\n valid = False\n \n return(valid)","def has_cycles(graph):\n path = set()\n\n def visit(node):\n path.add(node)\n for neighbour in graph.edges[node]:\n if neighbour in path or visit(neighbour):\n return True\n path.remove(node)\n return False\n\n return any(visit(node) for node in graph.nodes)","def nodes_row_similar(all_rows: set[tuple[str, str, str, int, int, int]],\n identifier: tuple[str, str, str, int, int, int]) -> bool:\n for row in all_rows:\n if row[0] == identifier[0] and row[1] == identifier[1]:\n return True\n return False","def inside_itself(self):\n for i in range(2, len(self.nodes)):\n if self.nodes[0] == self.nodes[i]:\n return True\n return False","def is_consistent(self, item):\n targets = set(ident for ident, node in self._nodes.iteritems() \\\n if node[item] == OCCUPIED)\n return self._check_consistency(item, [self.current], targets)","def count_fillin(graph, nodes):\n count = 0\n for v1 in nodes:\n for v2 in nodes:\n if v1 != v2 and v2 not in graph[v1]:\n count += 1\n return count / 2","def test_adjacent_none(graph_with_edges):\n assert graph_with_edges.adjacent('B', 'A') is False","def ase_cells_are_similar(ase_a, ase_b, thr=2):\n comp_similar = []\n for cell_a, cell_b in zip(ase_a.cell.flat, ase_b.cell.flat):\n comp_similar.append(round(cell_a, thr) == round(cell_b, thr))\n return all(comp_similar)","def validate_graph(self) -> bool:\n return True","def test_is_strongly_connected(self):\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\n assert_true(is_strongly_connected(G))","def is_graph(g):\n # g must be list\n if type(g) is not list:\n return False\n n = len(g)\n\n # Neighbors must all be vertices, and given in order, no dups\n for adjl in g:\n # Each adj list must be of type list\n if type(adjl) is not list:\n return False\n # Neighbors must be ints in [0,n)\n for v in adjl:\n if type(v) is not int:\n return False\n if v < 0 or v >= n:\n return False\n # Check adj list sorted & no duplicates\n # (Do *after* above so we know nbrs can be ordered & hashed)\n if adjl != sorted(list(set(adjl))):\n return False\n\n # Edges must be symmetric, and no loops\n for v1 in range(n):\n if v1 in g[v1]:\n return False\n for v2 in range(v1):\n e12 = v2 in g[v1]\n e21 = v1 in g[v2]\n if e12 != e21:\n return False\n return True","def relation_set_has_contradictions(relations):\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\n return 1 < sum([has_cnc, has_decreases, has_increases])","def is_boundary_edge(a, b, bdy_edges):\n for edge in bdy_edges:\n a0, b0 = edge\n if a == a0 and b == b0:\n return True\n return False","def num_vertices(graph1: list, graph2: list):\n if len(graph1[0]) != len(graph2[0]):\n return False\n return True","def node_is_edge(self, node: MazeCell) -> bool:\n return node.x == 0 or node.x == self._ncols - 1 or node.y == 0 or node.y == self._nrows - 1","def isomorphic(graph1, graph2):\r\n\r\n gd1 = _TripleCanonicalizer(graph1).to_hash()\r\n gd2 = _TripleCanonicalizer(graph2).to_hash()\r\n return gd1 == gd2","def check_edge_list(src_nodes, dst_nodes, edge_weights):\n\n if len(src_nodes) != len(dst_nodes):\n raise EdgeListError(\"src_nodes and dst_nodes must be of same length.\")\n\n if edge_weights is None:\n return\n\n if len(edge_weights) != len(src_nodes):\n raise EdgeListError(\"src_nodes and edge_weights must be of same length.\")","def is_clique(G,S): #set of vertices where every pair in the set forms an edge \n for v in S:\n if list(set(S)&set(neighbors(G,v))) != []: #[] <-- empty list\n return False\n \n return True"],"string":"[\n \"def __has_multiple_edges(self):\\n return \\\\\\n len(\\n list(\\n [\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n ] # the length of the list which allows duplicates...\\n )\\n ) != \\\\\\n len(\\n set(\\n {\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n } # ...should equal the length of the set that does not allow duplicates\\n )\\n ) # return True if the two data structures are equal in size and False otherwise\",\n \"def graph_is_connected(node_count, edges):\\n\\n disjoint_set = disjoint.DisjointSet(node_count + 1)\\n\\n for a, b in edges:\\n disjoint_set.union(a, b)\\n\\n # Check if all nodes are part of the same set\\n\\n root = disjoint_set.root(1)\\n\\n for i in range(2, node_count + 1):\\n if disjoint_set.root(i) != root:\\n return False\\n\\n return True\",\n \"def check_regularity(edges):\\n for a, b in edges:\\n counter_a = 0\\n counter_b = 0\\n for x, y in edges:\\n if a == x or a == y:\\n counter_a += 1\\n if b == x or b == y:\\n counter_b += 1\\n assert (counter_a > 0) and (counter_b > 0)\\n if (counter_a == 1) or (counter_b == 1):\\n raise Exception(\\\"Boundary is not closed.\\\")\\n if (counter_a > 2) or (counter_b > 2):\\n raise Exception(\\\"More than two edges share a node.\\\")\",\n \"def nodes_are_interconnected(graph, nodes):\\n \\n nid_list = []\\n for node in nodes:\\n if hasattr(node, 'nid'):\\n nid_list.append(node.nid)\\n elif node in graph.nodes:\\n nid_list.append(node)\\n else:\\n raise 'Node not in graph {0}'.format(node)\\n\\n nid_list = set(nid_list)\\n\\n collection = []\\n for nid in nid_list:\\n query = set(graph.adjacency[nid] + [nid])\\n collection.append(query.intersection(nid_list) == nid_list)\\n \\n return all(collection)\",\n \"def any_edges_intersect(nodes, edges):\\n for i in range(len(edges)):\\n for j in range(i+1, len(edges)):\\n e1 = edges[i]\\n e2 = edges[j]\\n if e1[1] == e2[0] or e1[0] == e2[1]:\\n continue\\n if two_edges_intersect(nodes, e1, e2):\\n return True\\n return False\",\n \"def haveNoSameEdges(seg1,seg2,segmentsMeta):\\n seg1Edges = segmentsMeta['edges'][seg1]\\n seg2Edges = segmentsMeta['edges'][seg2]\\n return not any(a==b for a in seg1Edges for b in seg2Edges)\",\n \"def graph_has_self_loops(edges):\\n\\n for a, b in edges:\\n if a == b:\\n return True\\n\\n return False\",\n \"def has_cycle(graph):\\n ds = DisjointSet()\\n\\n # creates a set of all graph nodes\\n node_set = set()\\n for edge in graph:\\n node_set.add(edge.node1)\\n node_set.add(edge.node2)\\n\\n for item in node_set:\\n ds.make_set(item)\\n\\n for edge in graph:\\n same_set = ds.union(edge.node1, edge.node2)\\n if same_set:\\n return True\\n\\n return False\",\n \"def CompareEdges(self,edge,dict):\\n \\\"\\\"\\\"Does not assume symmetric edge lists, though you should probably have them\\\"\\\"\\\"\\n # Edge is a tuple with two nodes\\n # Dict is a dictionary of node-keys and tuple (node,float) values\\n if edge[0] in dict.keys():\\n if edge[1] in [x[0] for x in dict[edge[0]]]:\\n return True\\n else:\\n return False\\n else:\\n if edge[1] in dict.keys():\\n if edge[0] in [x[0] for x in dict[edge[1]]]:\\n return True\\n else:\\n return False\\n else:\\n return False\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def edge_intersects_edges(e1, nodes, edges):\\n for i in range(len(edges)):\\n e2 = edges[i]\\n if e1[1] == e2[0] or e1[0] == e2[1]:\\n continue\\n if two_edges_intersect(nodes, e1, e2):\\n return True\\n return False\",\n \"def are_connected(self, node1, node2):\\n return bool( self.get_edge(node1, node2) )\",\n \"def has_multiple_edges(self):\\n # Create a list of edge 2-tuples (a, b)\\n edge_tuples = [(e['from_id'], e['to_id']) for e in self._edges]\\n if len(edge_tuples) > len(set(edge_tuples)): # Do 'real' multiple edges exist?\\n return True\\n\\n # Create a list of edge 2-tuples (a, b) with a <= b\\n edge_tuples = [(min(e['from_id'], e['to_id']), max(e['from_id'], e['to_id'])) for e in self._edges]\\n edge_tuples_set = set(edge_tuples)\\n\\n if len(edge_tuples) == 2 * len(edge_tuples_set): # This only happens if for each edge (a, b) also (b, a) exists\\n return False\\n else:\\n # The set kicks out duplicate edges => less edges in the set means there were multiple edges\\n return len(edge_tuples) > len(edge_tuples_set)\",\n \"def is_connected_same_node(graph, node_u, node_v):\\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\\n if out_neighbor_u == out_neighbor_v:\\n return True\\n return False\",\n \"def __has_conflicting_node_names(self):\\n # check length of sets to determine if overlap exists\\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())\",\n \"def consistency(node, sequence, orientation, overlap):\\n from_id, to_id = node\\n from_sequence, to_sequence = sequence\\n from_orn, to_orn = orientation\\n if from_orn == '-':\\n from_sequence = reverse_and_complement(from_sequence)\\n if to_orn == '-':\\n to_sequence = reverse_and_complement(to_sequence)\\n size_overlap = real_overlap(from_sequence, to_sequence)\\n if not size_overlap == overlap:\\n GRAPH_LOGGER.debug('Edge between node %s and %s have \\\\\\n \\tno consistency between CIGAR overlap end \\\"real\\\" overlap', from_id, to_id)\\n return False\\n\\n return True\",\n \"def get_inconsistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def is_consistent(graph, goal):\\n\\n consistent = True\\n\\n for edge in graph.edges:\\n consistent &= edge.length >= abs(\\n graph.get_heuristic(edge.node1, goal) -\\n graph.get_heuristic(edge.node2, goal)\\n )\\n\\n if not consistent:\\n break\\n\\n return consistent\",\n \"def test_same_node_is_reachable(self):\\n # G is an arbitrary tournament on ten nodes.\\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\\n assert_true(all(is_reachable(G, v, v) for v in G))\",\n \"def _degree_has_changed(first, second):\\n return len(set(first) ^ set(second)) != 0\",\n \"def is_connected(self, node1, node2):\\r\\n\\r\\n return node1 in self.graph and node2 in self.graph[node1]\",\n \"def consistent(h, phi):\\n for n in h: # for each node in h\\n if phi(n) in h and phi(n) not in h:\\n return False\\n return True\",\n \"def test_consistent_ids(self) -> None:\\n bnode = BNode()\\n g0_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Golan Trevize\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n bnode = BNode()\\n g1_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Janov Pelorat\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n\\n g0 = Graph()\\n g0 += g0_ts\\n cg0 = to_canonical_graph(g0)\\n cg0_ts = GraphHelper.triple_set(cg0)\\n\\n g1 = Graph()\\n g1 += g1_ts\\n cg1 = to_canonical_graph(g1)\\n cg1_ts = GraphHelper.triple_set(cg1)\\n\\n assert cg0_ts.issubset(\\n cg1_ts\\n ), \\\"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\\\"\",\n \"def graph_has_duplicates(edges, is_bidirectional=True):\\n\\n curr_edges = set()\\n\\n for edge in edges:\\n if is_bidirectional and edge[0] > edge[1]:\\n edge = (edge[1], edge[0])\\n\\n if edge in curr_edges:\\n return True\\n else:\\n curr_edges.add(edge)\\n\\n return False\",\n \"def test_edges(self):\\n\\n edge_list = self.g.edges()\\n self.assertEqual(42, len(edge_list))\\n\\n # p1 p3 and p3 p1 are valid edges\\n t1 = ('p1', 'p3')\\n self.assertTrue(t1 in edge_list)\\n\\n t2 = ('p3', 'p1')\\n self.assertTrue(t2 in edge_list)\\n\\n made_up = ('z1', 'q123')\\n self.assertFalse(made_up in edge_list)\\n\\n return None\",\n \"def num_edges(graph1: list, graph2: list):\\n check1 = 0\\n check2 = 0\\n for row, _ in enumerate(graph1):\\n for column, _ in enumerate(graph1[row]):\\n if graph1[row][column] == 1:\\n check1 += 1\\n if graph2[row][column] == 1:\\n check2 += 1\\n return check1 == check2\",\n \"def is_independent_set(G, nodes):\\n nodes = set(nodes)\\n if not nodes.issubset(G):\\n raise nx.NetworkXUnfeasible(\\n \\\"%s is not a subset of the nodes of G\\\" % nodes)\\n neighbors = []\\n [neighbors.extend( G.neighbors(v) ) for v in nodes]\\n neighbors = set(neighbors)\\n if set.intersection(neighbors, nodes):\\n return False;\\n else:\\n return True;\",\n \"def check(self, expected, debug=True):\\r\\n for v1, v2, go in expected:\\r\\n for gj, oj in go:\\r\\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\\r\\n assert r1 == oj\\r\\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\\r\\n assert r2 == oj\",\n \"def is_connected(self, node1, node2):\\r\\n\\r\\n return node1 in self._graph and node2 in self._graph[node1]\",\n \"def check_duplicate_schema(schema_edges, node_list):\\n # checking for duplicates amounts to checking the min difference between any two nodes being greater than 1\\n differences = []\\n for node in node_list:\\n min_diff = sys.maxsize\\n for node2 in node_list:\\n if node == node2:\\n continue\\n diff = abs(node - node2)\\n if diff < min_diff:\\n min_diff = diff\\n differences.append(min_diff)\\n # all differences should be 1 if this chain is not a duplicate\\n return any(difference != 1 for difference in differences)\",\n \"def __eq__(self, other):\\n if not type(other) == type(self):\\n return False\\n sedges, oedges = self.edges, other.edges\\n return ((len(sedges) == len(oedges)) and\\n all(numpy.all(se == oe) for (se, oe) in zip(sedges, oedges)))\",\n \"def consistent(self, assignment):\\n for node1 in assignment:\\n for node2 in assignment:\\n\\n if node1 != node2:\\n #returns False if any assignmed words are the same\\n if assignment[node1] == assignment[node2]:\\n return False\\n\\n overlap= self.crossword.overlaps[node1,node2]\\n if overlap != None:\\n #checks if words assigned to node overlaps are the same letter\\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\\n return False\\n\\n return True\",\n \"def test_if_nodes_are_in_same_chunk(self, node_ids: Sequence[np.uint64]\\n ) -> bool:\\n assert len(node_ids) == 2\\n return self.get_chunk_id(node_id=node_ids[0]) == \\\\\\n self.get_chunk_id(node_id=node_ids[1])\",\n \"def compare(self, node) -> bool:\\n\\t\\t# No conflicts, Return True\\n\\t\\treturn True\",\n \"def same_edge(self, other, precision=0):\\n return self.id == other.id \\\\\\n and self.start_node == other.start_node \\\\\\n and self.end_node == other.end_node \\\\\\n and abs(self.cost - other.cost) <= precision \\\\\\n and abs(self.reverse_cost - other.reverse_cost) <= precision \\\\\\n and self.reversed == other.reversed\",\n \"def check_undirected(graph):\\n for node in graph:\\n for neighbor in graph[node]:\\n if node not in graph[neighbor]:\\n return False\\n return True\",\n \"def contains_edge(self, node, other_node):\\n return \\\\\\n {node.get_name(), other_node.get_name()} in \\\\\\n list([\\n {edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()}\\n for edge in self.get_edges()\\n ]) # return true if there exists an edge between the input nodes and false otherwise\",\n \"def is_all_visited(self):\\n cond = [node.visited if node and node.belongs and node.valid else True for node in self.nodes.flatten()]\\n return all(cond)\",\n \"def is_graph_isomorphic(self):\\n out=True\\n for node in self.node_names:\\n self.move_to_node(node)\\n if not self.check_closed_path:\\n out=False\\n return out\",\n \"def perms_are_connected(g, n):\\n from sage.graphs.graph import Graph\\n G = Graph()\\n if g:\\n G.add_vertices(g[0].domain())\\n for p in g:\\n G.add_edges(p.dict().items())\\n return G.is_connected()\",\n \"def test_nodes_exist(graph_no_edges):\\n for node in graph_no_edges:\\n assert graph_no_edges.has_node(node)\",\n \"def is_edge_connected_dfs(adj_dict, vertex, edges, check, check_edges):\\n check[vertex] = True\\n length = len(edges)\\n for vert, weigth in adj_dict[vertex]:\\n for i in range(length):\\n a, b, c = edges[i]\\n if (a == vertex and b == vert and c == weigth):\\n check_edges[i] = True\\n elif (a == vert and b == vertex and c == weigth):\\n check_edges[i] = True\\n if not check[vert]:\\n is_edge_connected_dfs(adj_dict, vert, edges, check, check_edges)\",\n \"def _vertices_are_equal(\\n vertices1: List[np.ndarray], vertices2: List[np.ndarray]\\n) -> bool:\\n if len(vertices1) != len(vertices2):\\n return False\\n diff = vertices1 - vertices2\\n if np.abs(np.max(diff)) < ways_are_equal_tolerance:\\n return True\\n return False\",\n \"def is_edge_connected(num_vertices, adj_dict, edges):\\n if not num_vertices or not adj_dict:\\n return True\\n check = { i:False for i in adj_dict.keys() }\\n check_edges = [False for _ in range(len(edges))]\\n first_vertex = list(adj_dict.keys())[0]\\n is_edge_connected_dfs(adj_dict, first_vertex, edges, check, check_edges)\\n return not False in check_edges\",\n \"def isEquivalent(self, oth: 'StateNode') -> bool:\\n a = [self.table[i][j] for i in self.state[0] for j in self.state[1]]\\n b = [oth.table[i][j] for i in oth.state[0] for j in oth.state[1]]\\n if len(a) != len(b):\\n return False\\n if len(a) < 1 or len(b) < 1 or len(a[0]) != len(b[0]):\\n return False\\n for i in range(len(a)):\\n for j in range(len(a[0])):\\n if a[i][j] != b[i][j]:\\n return False\\n return True\",\n \"def permissible(e1, e2):\\n return e1[1] == e2[0] and \\\\\\n total_edge_length(e1, e2) < maximum_distance and \\\\\\n total_edge_angle(e1, e2) < maximum_angle_delta\",\n \"def similar(g1, g2):\\r\\n return all(t1 == t2 for (t1, t2) in _squashed_graphs_triples(g1, g2))\",\n \"def is_directed(G):\\n return G.is_directed()\",\n \"def are_connected(self, person1, person2):\\n\\n possible_nodes = Queue()\\n seen = set()\\n possible_nodes.enqueue(person1)\\n seen.add(person1)\\n\\n while not possible_nodes.is_empty():\\n person = possible_nodes.dequeue()\\n print(\\\"checking\\\", person)\\n if person is person2:\\n return True\\n else:\\n for cohabitant in person.adjacent - seen:\\n possible_nodes.enqueue(cohabitant)\\n seen.add(cohabitant)\\n print(\\\"added to queue:\\\", cohabitant)\\n return False\",\n \"def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\\n logger.debug(f\\\"checking symmtrical connections for nodes: {node1}, {node2}\\\")\\n tree1 = set(get_next_level(G,[node1]))\\n tree2 = set(get_next_level(G,[node2]))\\n traversed1.append(node1)\\n traversed2.append(node2)\\n if tree1==tree2:\\n return True\\n while(len(list(tree1))== len(list(tree2)) > 0):\\n logger.debug(f\\\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\\\")\\n tree1 = set(tree1) - set(traversed1)\\n tree2 = set(tree2) - set(traversed2)\\n\\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\\n return True\\n else:\\n traversed1+=list(tree1)\\n traversed2+=list(tree2)\\n tree1=set(get_next_level(G,tree1))\\n tree2=set(get_next_level(G,tree2))\\n\\n logger.debug(f\\\"Non symmetrical branches for nets: {node1}, {node2}\\\")\\n return False\",\n \"def compare_nodes(n1, n2):\\n return n1['g_val'] + n1['h_val'] < n2['g_val'] + n2['h_val']\",\n \"def cycle_check(node):\\n node_marker1 = node_marker2 = node\\n\\n while node_marker2 and node_marker2.nextnode:\\n node_marker1 = node_marker1.nextnode # node_marker1 runs 1 node at each step\\n node_marker2 = node_marker2.nextnode.nextnode # node_marker2 runs 2 node at each step\\n if node_marker1 == node_marker2:\\n return True # meaning that they are meeting each other at some point because of linked list is cycle.\\n # End of while\\n return False\",\n \"def edges_is_closed_curve(edges):\\n e_prev = first = edges[0]\\n for e in edges[1:]:\\n if e_prev[1] != e[0]:\\n if e_prev[1] == first[0]:\\n # new loop\\n first = e\\n else:\\n return False\\n e_prev = e\\n if e_prev[1] != first[0]:\\n return False\\n return True\",\n \"def equivalent(kls, first, second):\\n if first.empty() and second.empty():\\n return True\\n elif first.vertices.shape[0] != second.vertices.shape[0]:\\n return False\\n elif first.edges.shape[0] != second.edges.shape[0]:\\n return False\\n\\n EPSILON = 1e-7\\n\\n vertex1, ct1 = np.unique(first.vertices, axis=0, return_counts=True)\\n vertex2, ct2 = np.unique(second.vertices, axis=0, return_counts=True)\\n \\n vertex_match = np.all(np.abs(vertex1 - vertex2) < EPSILON)\\n ct_match = np.all(ct1 == ct2)\\n if not (vertex_match and ct_match):\\n return False\\n\\n g1 = nx.Graph()\\n g1.add_edges_from(first.edges)\\n g2 = nx.Graph()\\n g2.add_edges_from(second.edges)\\n edges_match = nx.is_isomorphic(g1, g2)\\n del g1 \\n del g2\\n\\n if not edges_match:\\n return False\\n\\n second_verts = {}\\n for i, vert in enumerate(second.vertices):\\n second_verts[tuple(vert)] = i\\n \\n attrs = [ attr['id'] for attr in first.extra_attributes ]\\n for attr in attrs:\\n buf1 = getattr(first, attr)\\n buf2 = getattr(second, attr)\\n if len(buf1) != len(buf2):\\n return False\\n\\n for i in range(len(buf1)):\\n i2 = second_verts[tuple(first.vertices[i])]\\n if buf1[i] != buf2[i2]:\\n return False\\n\\n return True\",\n \"def has_consistent_orientation(triangles):\\n num_triangles = len(triangles)\\n for tri_idx in range(num_triangles):\\n for edge in range(3):\\n if not has_same_edge_orientation(triangles, tri_idx, edge):\\n return False\\n return True\",\n \"def connected(self, x, y):\\n\\n return self.__find_root(x) == self.__find_root(y)\",\n \"def has_relationship(self, source_node: Node, target_node: Node) -> bool: # pylint: disable=no-self-use\\n return source_node.node_id in target_node.in_nodes_ids\",\n \"def is_directed(self):\\n return self._incoming is not self._outgoing\\n # directed if maps are distinct\",\n \"def IsEulerGraph(self):\\n\\n for node in self.nodes:\\n if ((len(node.neighbours) % 2) == 1) or (len(node.neighbours) == 0):\\n return False\\n return True\",\n \"def isSameState(self, oth: 'StateNode') -> bool:\\n def sameElements(a: list, b: list):\\n return len([1 for i, j in zip(a, b) if i == j]) == len(a) and len(a) == len(b)\\n if self.table != oth.table:\\n return False\\n a_lin, a_col = self.state\\n b_lin, b_col = oth.state\\n return sameElements(a_lin, b_lin) and sameElements(a_col, b_col)\",\n \"def _check_consistency(self, item, path, targets):\\n for neighbor in self._edges[path[-1]]:\\n if neighbor in path:\\n continue\\n elif self._nodes[neighbor][item] in (EMPTY, VISITED):\\n continue\\n\\n remaining = set(targets)\\n if neighbor in targets:\\n remaining.remove(neighbor)\\n if len(remaining) == 0:\\n return True\\n\\n if self._check_consistency(item, path + [neighbor], remaining):\\n return True\\n\\n return False\",\n \"def check_adjacency(layer_a, layer_b, topology):\\n adjacency = None\\n for node in topology.graph.node.keys():\\n if layer_a in node:\\n # print topology.graph.edge[node].keys()\\n for edge in topology.graph.edge[node].keys():\\n if layer_b in edge:\\n # print topology.graph.edge[node][edge]\\n # print \\\"Node \\\",layerA,\\\" and \\\",layerB,\\\" share an edge!\\\"\\n adjacency = True\\n if adjacency is True:\\n return True\\n else:\\n return False\",\n \"def test_case7(self):\\n\\n graph3 = self.graph1.merge(self.graph2)\\n\\n expected = {'supervisor1':['student1','student2','student4'],'supervisor2':['student4','student1','student3'],'supervisor3':['student3','student2']}\\n\\n result = True\\n\\n for sup in expected:\\n for stu in expected[sup]:\\n if not graph3.isEdge(sup,stu):\\n result = False\\n break\\n\\n self.assertTrue(result)\",\n \"def are_the_same(node_before, node_after) -> bool:\\n\\n if node_before.algorithm != node_after.algorithm:\\n return False\\n elif not _is_output_name_same(node_before, node_after):\\n return False\\n else:\\n for attr in interested_attrs:\\n if _exists_attr(attr, node_before, node_after) == 1 or \\\\\\n _exists_attr(attr, node_before, node_after) == 2:\\n return False\\n elif _exists_attr(attr, node_before, node_after) == 12 and \\\\\\n node_before.attributes[attr] != node_after.attributes[attr]:\\n return False\\n return True\",\n \"def nodes_are_equal(node1, node2):\\n\\n try:\\n return dump_ast(node1).strip() == dump_ast(node2).strip() and \\\\\\n node1.lineno == node2.lineno and \\\\\\n node1.col_offset == node2.col_offset\\n except:\\n return False\",\n \"def check_connected(self, update=True):\\n # update if needed\\n if update:\\n\\n self.update_neighbors()\\n\\n # go through each node checking that each degree id greater than 0\\n for node in self.nodes:\\n\\n # only one node needs to be disconnected to fail\\n if len(self.nodes[node].neighbors) < 1:\\n return False\\n\\n return True\",\n \"def is_weakly_connected(G):\\n if len(G) == 0:\\n raise nx.NetworkXPointlessConcept(\\n \\\"\\\"\\\"Connectivity is undefined for the null graph.\\\"\\\"\\\")\\n\\n return len(list(weakly_connected_components(G))[0]) == len(G)\",\n \"def is_connected(graph):\\n return nx.is_connected(graph.graph)\",\n \"def is_connected(self):\\n vs = self.vertices()\\n visited = self.bfs(vs[0])\\n return len(visited) == len(vs)\",\n \"def valid_chain(chain):\\n\\n for i in range(len(chain) - 1):\\n parent_edge = chain[i]\\n child_edge = chain[i + 1]\\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\\n if not parent_edge[1] == child_edge[0]:\\n # if this isn't\\n return False\\n return True\",\n \"def is_connected(self):\\n if self.V < 1:\\n raise ValueError(\\\"empty graph\\\")\\n if self.V < 2:\\n return True\\n if self.E == 0:\\n return False\\n cc = self.cc()\\n return int(cc.max() == 0)\",\n \"def consistent(self):\\n return all((constraint.consistent() for constraint in self.constraints))\",\n \"def is_equivalence(self) -> bool:\",\n \"def is_connected(object_one, object_two):\\n\\n for vert_one in object_one.Vertexes:\\n for vert_two in object_two.Vertexes:\\n if (vert_one.X == vert_two.X) and (vert_one.y == vert_two.y):\\n return True\\n\\n return False\",\n \"def test_case21(self):\\n\\n result= self.graph1.isEdge(\\\"supervisor2\\\",\\\"student1\\\")\\n\\n self.assertFalse(result)\",\n \"def is_directed(self) -> bool:\\n return True\",\n \"def is_connected(self):\\n \\n # All the vertices in the graph\\n vertices = set(self.vertices())\\n \\n # Take a random vertex to start the search from\\n vertex_search_start = self._edges.keys()[0]\\n vertices_found = set(self.DFS(vertex_search_start))\\n \\n return vertices == vertices_found\",\n \"def is_cyclic(self):\\n \\n visited = set()\\n path = []\\n \\n for node in self.node_set:\\n if node not in visited:\\n if self.is_cyclic_helper(node, visited, path) is True:\\n return True \\n \\n visited.clear()\\n path.clear()\\n return False\",\n \"def is_acyclic(graph):\\n visited = []\\n dfs_seq = DFSIterator(graph)\\n\\n for node in dfs_seq:\\n visited.insert(0, node)\\n node_neighbors = graph.get_neighbors(node)\\n \\n for neighbor in node_neighbors:\\n if neighbor in visited:\\n return False\\n\\n return True\",\n \"def _semantic_feasibility(self, G1_node, G2_node):\\n # Make sure the nodes match\\n if self.node_match is not None:\\n\\n nm = self.node_match(G1_node, G2_node)\\n if not nm:\\n return False\\n\\n # Make sure the edges match\\n if self.edge_match is not None:\\n\\n # Cached lookups\\n G1_adj = self.G1_adj\\n G2_adj = self.G2_adj\\n core_1 = self.core_1\\n edge_match = self.edge_match\\n\\n for neighbor in G1_adj[G1_node]:\\n # G1_node is not in core_1, so we must handle R_self separately\\n if neighbor == G1_node:\\n if not edge_match(G1_adj[G1_node][G1_node],\\n G2_adj[G2_node][G2_node]):\\n return False\\n elif neighbor in core_1:\\n if not edge_match(G1_adj[G1_node][neighbor],\\n G2_adj[G2_node][core_1[neighbor]]):\\n return False\\n # syntactic check has already verified that neighbors are symmetric\\n\\n return True\",\n \"def has_edge(self, i: Node, j: Node) -> bool:\\n return frozenset({i, j}) in self._edges\",\n \"def isValidCompatible(cls,root):\\n valid = True\\n # the order of node types in chains is restricted\\n # (this would be easier if the data was in a Corpus-instance)\\n allowed = NX.XDiGraph(selfloops=True)\\n\\n # continue from here!\\n allowed.add_edge('Physical','Physical')\\n allowed.add_edge('Property','Physical')\\n allowed.add_edge('Process','Physical')\\n allowed.add_edge('Regulation','Physical')\\n\\n allowed.add_edge('Property','Property')\\n allowed.add_edge('Process','Property')\\n allowed.add_edge('Regulation','Property')\\n\\n allowed.add_edge('Property','Process')\\n# allowed.add_edge('Process','Process')\\n allowed.add_edge('Regulation','Process')\\n\\n allowed.add_edge('Property','Regulation')\\n# allowed.add_edge('Process','Regulation')\\n allowed.add_edge('Regulation','Regulation')\\n\\n mapping = {}\\n for a in root.find(\\\"ontologies\\\").findall(\\\"ontology\\\"):\\n if a.attrib['id']=='interaction':\\n for x in a.getiterator(\\\"ontnode\\\"):\\n if x.attrib.has_key('effect') and x.attrib['effect'].endswith('regulation'):\\n t = 'Regulation'\\n else:\\n t = x.attrib['onttype']\\n mapping[x.attrib['id']] = t\\n \\n for a in root.getiterator(\\\"relannotation\\\"):\\n t2type = dict( [(x.attrib['id'],x.attrib['type'])\\n for x in a.findall(\\\"reltoken\\\")] )\\n n2t = dict( [(x.attrib['id'],x.attrib['token'])\\n for x in a.findall(\\\"relnode\\\")] )\\n for x in a.findall(\\\"reledge\\\"):\\n bt = t2type[n2t[x.attrib['bgn']]]\\n et = t2type[n2t[x.attrib['end']]]\\n bgn = mapping[bt]\\n end = mapping[et]\\n if not allowed.has_edge(bgn,end):\\n printError(cls,inspect.stack()[1][3],\\n \\\"%s -- %s (%s) -> %s (%s) is not a valid edge\\\"%\\n (x.attrib['id'].split('.')[1],bgn,bt,end,et))\\n valid = False\\n \\n return(valid)\",\n \"def has_cycles(graph):\\n path = set()\\n\\n def visit(node):\\n path.add(node)\\n for neighbour in graph.edges[node]:\\n if neighbour in path or visit(neighbour):\\n return True\\n path.remove(node)\\n return False\\n\\n return any(visit(node) for node in graph.nodes)\",\n \"def nodes_row_similar(all_rows: set[tuple[str, str, str, int, int, int]],\\n identifier: tuple[str, str, str, int, int, int]) -> bool:\\n for row in all_rows:\\n if row[0] == identifier[0] and row[1] == identifier[1]:\\n return True\\n return False\",\n \"def inside_itself(self):\\n for i in range(2, len(self.nodes)):\\n if self.nodes[0] == self.nodes[i]:\\n return True\\n return False\",\n \"def is_consistent(self, item):\\n targets = set(ident for ident, node in self._nodes.iteritems() \\\\\\n if node[item] == OCCUPIED)\\n return self._check_consistency(item, [self.current], targets)\",\n \"def count_fillin(graph, nodes):\\n count = 0\\n for v1 in nodes:\\n for v2 in nodes:\\n if v1 != v2 and v2 not in graph[v1]:\\n count += 1\\n return count / 2\",\n \"def test_adjacent_none(graph_with_edges):\\n assert graph_with_edges.adjacent('B', 'A') is False\",\n \"def ase_cells_are_similar(ase_a, ase_b, thr=2):\\n comp_similar = []\\n for cell_a, cell_b in zip(ase_a.cell.flat, ase_b.cell.flat):\\n comp_similar.append(round(cell_a, thr) == round(cell_b, thr))\\n return all(comp_similar)\",\n \"def validate_graph(self) -> bool:\\n return True\",\n \"def test_is_strongly_connected(self):\\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\\n assert_true(is_strongly_connected(G))\",\n \"def is_graph(g):\\n # g must be list\\n if type(g) is not list:\\n return False\\n n = len(g)\\n\\n # Neighbors must all be vertices, and given in order, no dups\\n for adjl in g:\\n # Each adj list must be of type list\\n if type(adjl) is not list:\\n return False\\n # Neighbors must be ints in [0,n)\\n for v in adjl:\\n if type(v) is not int:\\n return False\\n if v < 0 or v >= n:\\n return False\\n # Check adj list sorted & no duplicates\\n # (Do *after* above so we know nbrs can be ordered & hashed)\\n if adjl != sorted(list(set(adjl))):\\n return False\\n\\n # Edges must be symmetric, and no loops\\n for v1 in range(n):\\n if v1 in g[v1]:\\n return False\\n for v2 in range(v1):\\n e12 = v2 in g[v1]\\n e21 = v1 in g[v2]\\n if e12 != e21:\\n return False\\n return True\",\n \"def relation_set_has_contradictions(relations):\\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\\n return 1 < sum([has_cnc, has_decreases, has_increases])\",\n \"def is_boundary_edge(a, b, bdy_edges):\\n for edge in bdy_edges:\\n a0, b0 = edge\\n if a == a0 and b == b0:\\n return True\\n return False\",\n \"def num_vertices(graph1: list, graph2: list):\\n if len(graph1[0]) != len(graph2[0]):\\n return False\\n return True\",\n \"def node_is_edge(self, node: MazeCell) -> bool:\\n return node.x == 0 or node.x == self._ncols - 1 or node.y == 0 or node.y == self._nrows - 1\",\n \"def isomorphic(graph1, graph2):\\r\\n\\r\\n gd1 = _TripleCanonicalizer(graph1).to_hash()\\r\\n gd2 = _TripleCanonicalizer(graph2).to_hash()\\r\\n return gd1 == gd2\",\n \"def check_edge_list(src_nodes, dst_nodes, edge_weights):\\n\\n if len(src_nodes) != len(dst_nodes):\\n raise EdgeListError(\\\"src_nodes and dst_nodes must be of same length.\\\")\\n\\n if edge_weights is None:\\n return\\n\\n if len(edge_weights) != len(src_nodes):\\n raise EdgeListError(\\\"src_nodes and edge_weights must be of same length.\\\")\",\n \"def is_clique(G,S): #set of vertices where every pair in the set forms an edge \\n for v in S:\\n if list(set(S)&set(neighbors(G,v))) != []: #[] <-- empty list\\n return False\\n \\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.710841","0.68671525","0.6761228","0.66784406","0.66491693","0.66183716","0.6618279","0.65234625","0.6509124","0.64982206","0.6469651","0.644774","0.6418613","0.6405866","0.6381723","0.6370003","0.63498205","0.6347336","0.63372046","0.62504184","0.62285084","0.6224007","0.6222094","0.6221853","0.62153304","0.61954385","0.6186029","0.6183487","0.6162563","0.61420447","0.60951835","0.6093591","0.60870576","0.60866886","0.6074518","0.6064833","0.60574394","0.6028865","0.60203606","0.60202676","0.6014694","0.5998531","0.59966075","0.59946096","0.5987497","0.5986444","0.59777975","0.5968954","0.5968717","0.5960592","0.5945957","0.5942715","0.5921455","0.5908806","0.5907216","0.59033895","0.58952945","0.5882437","0.58767515","0.587503","0.5863548","0.5858833","0.58481824","0.5823562","0.5819785","0.58084786","0.579224","0.57877","0.5777344","0.57751584","0.5769666","0.5752543","0.574948","0.5746839","0.57464844","0.5743184","0.5741662","0.5739243","0.57350916","0.5727032","0.5707816","0.5705751","0.5700264","0.56931543","0.5691537","0.5688449","0.5686572","0.56689465","0.5667539","0.5667236","0.5666965","0.5664861","0.5661417","0.5659647","0.56457394","0.5637011","0.5632418","0.56320125","0.5629864","0.56284434"],"string":"[\n \"0.710841\",\n \"0.68671525\",\n \"0.6761228\",\n \"0.66784406\",\n \"0.66491693\",\n \"0.66183716\",\n \"0.6618279\",\n \"0.65234625\",\n \"0.6509124\",\n \"0.64982206\",\n \"0.6469651\",\n \"0.644774\",\n \"0.6418613\",\n \"0.6405866\",\n \"0.6381723\",\n \"0.6370003\",\n \"0.63498205\",\n \"0.6347336\",\n \"0.63372046\",\n \"0.62504184\",\n \"0.62285084\",\n \"0.6224007\",\n \"0.6222094\",\n \"0.6221853\",\n \"0.62153304\",\n \"0.61954385\",\n \"0.6186029\",\n \"0.6183487\",\n \"0.6162563\",\n \"0.61420447\",\n \"0.60951835\",\n \"0.6093591\",\n \"0.60870576\",\n \"0.60866886\",\n \"0.6074518\",\n \"0.6064833\",\n \"0.60574394\",\n \"0.6028865\",\n \"0.60203606\",\n \"0.60202676\",\n \"0.6014694\",\n \"0.5998531\",\n \"0.59966075\",\n \"0.59946096\",\n \"0.5987497\",\n \"0.5986444\",\n \"0.59777975\",\n \"0.5968954\",\n \"0.5968717\",\n \"0.5960592\",\n \"0.5945957\",\n \"0.5942715\",\n \"0.5921455\",\n \"0.5908806\",\n \"0.5907216\",\n \"0.59033895\",\n \"0.58952945\",\n \"0.5882437\",\n \"0.58767515\",\n \"0.587503\",\n \"0.5863548\",\n \"0.5858833\",\n \"0.58481824\",\n \"0.5823562\",\n \"0.5819785\",\n \"0.58084786\",\n \"0.579224\",\n \"0.57877\",\n \"0.5777344\",\n \"0.57751584\",\n \"0.5769666\",\n \"0.5752543\",\n \"0.574948\",\n \"0.5746839\",\n \"0.57464844\",\n \"0.5743184\",\n \"0.5741662\",\n \"0.5739243\",\n \"0.57350916\",\n \"0.5727032\",\n \"0.5707816\",\n \"0.5705751\",\n \"0.5700264\",\n \"0.56931543\",\n \"0.5691537\",\n \"0.5688449\",\n \"0.5686572\",\n \"0.56689465\",\n \"0.5667539\",\n \"0.5667236\",\n \"0.5666965\",\n \"0.5664861\",\n \"0.5661417\",\n \"0.5659647\",\n \"0.56457394\",\n \"0.5637011\",\n \"0.5632418\",\n \"0.56320125\",\n \"0.5629864\",\n \"0.56284434\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6281837"},"document_rank":{"kind":"string","value":"19"}}},{"rowIdx":20170,"cells":{"query":{"kind":"string","value":"Returns if the set of relations contains a contradiction"},"document":{"kind":"string","value":"def relation_set_has_contradictions(relations):\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\n return 1 < sum([has_cnc, has_decreases, has_increases])"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def check_relations(self, relations):\n if self.debug:\n print(\"Checking relations\")\n result = False\n work_relations = []\n\n # Eliminate unnecessary(duplicated) clauses\n if relations[\"is_derived_from\"]:\n relations[\"has_derived_form\"] = True\n relations[\"is_derived_from\"] = False\n if relations[\"etymology\"]:\n relations[\"etymological_origin_of\"] = True\n relations[\"etymology\"] = False\n\n for relation in relations:\n if relations[relation]:\n result = True\n work_relations.append(relation)\n return result, work_relations","def _relation_check(self):\n seen = set()\n for entity in self.get_entities():\n for field in entity.fields.itervalues():\n if field.is_relation():\n seen.add(field.remote_name)\n missing = seen - set(self.entities.keys())\n if missing:\n raise exceptions.SchemaError(\n 'undefined entities referenced in relations: %s' % (\n ', '.join(missing)))","def test_conceptional_relations(id, conrel, expected_ids):\n synset = germanet_data.get_synset_by_id(id)\n related = synset.relations[conrel]\n np.testing.assert_equal(sorted([syn.id for syn in related]), sorted(expected_ids))","def has_conflict(self):\n for diffstat in self.diffstat():\n if diffstat.has_conflict:\n return True\n return False","def pair_has_contradiction(graph, u, v):\n relations = get_all_relations(graph, u, v)\n return relation_set_has_contradictions(relations)","def can_create_relation(self, rids):\n if len(rids) < 2:\n raise ValueError(\"It takes at least 2 to tango!\")\n rids = tuple(rids)\n existing = self.find_relations(rids[0], *rids[1:])\n if existing:\n cmp_set = set(rids)\n for rel_id in existing:\n if self.get(rel_id) == cmp_set:\n raise ValueError(\"Already has relations: %s\" % \", \".join(existing))","def is_equivalence(self) -> bool:","def exact_fact_check(self, triple, transitive=False):\n exists = self.knowledge_graph.check_triple_object_existence(triple, transitive)\n if exists is True:\n return 'exists', []\n conflicts = self.knowledge_graph.get_triples(triple.subject, triple.relation, transitive)\n if conflicts is not None:\n return 'conflicts', conflicts\n # The following checks triples with the same subject and object, but different relation. Are those conflict?\n # if conflicts is None:\n # conflicts = []\n # for obj in triple.objects:\n # relations = self.knowledge_graph.get_relation_triples(triple.subject, obj)\n # if relations is not None:\n # conflicts += relations\n # if len(conflicts) > 0:\n # return 'conflicts', conflicts\n return 'none', []","def consistent(self):\n return all((constraint.consistent() for constraint in self.constraints))","def is_relation(self, rel_name):\n return rel_name in self._declaration","def is_consistent(self, constraints):\n for constraint in constraints:\n if not constraint.is_satisfied_with(self):\n return False\n return True","def is_reflexive(fuzzy_set):\n\tfor index, element in enumerate(fuzzy_set.domain.domain_elements):\n\t\tif element[0] == element[1]:\n\t\t\tif not fuzzy_set.memberships[index] == 1:\n\t\t\t\treturn False\n\treturn True","def author_ManyToMany_entry_check(): #Old it was OneToMany before adding multiple authors\n import itertools\n entry_author_ids = itertools.chain(*Entry.objects.all().values_list('author_ids', flat=True))\n entry_author_ids_set = set(entry_author_ids)\n user_ids = set(User.objects.all().values_list('id',flat=True))\n\n author_id_not_in_user = entry_author_ids_set - user_ids\n\n if author_id_not_in_user:\n return (\"Error: There are entries without a correct cross relation with user: {}\"\n .format(\",\".join(str(s) for s in author_id_not_in_user)))\n else:\n return \"OK\"","def complete(self):\n return all((constraint.satisfied() for constraint in self.constraints))","def __has_multiple_edges(self):\n return \\\n len(\n list(\n [\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n ] # the length of the list which allows duplicates...\n )\n ) != \\\n len(\n set(\n {\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n } # ...should equal the length of the set that does not allow duplicates\n )\n ) # return True if the two data structures are equal in size and False otherwise","def __has_no_dependents (self, obj, constraints):\n failed = False\n while constraints and not failed:\n c = constraints [0]\n\n if c [1] == obj:\n failed = True\n\n constraints = constraints [1:]\n\n return not failed","def check_membership(self, ref_set, my_set):\n rset = set(ref_set)\n mset = set(my_set)\n if len(rset.intersection(mset)) > 0:\n return 1\n else:\n return 0","def can_satisfy_without_refs(self):\n\n if self.constraint_type in (self.ONE, self.AT_LEAST_ONE):\n result = any(not _is_ref_prop(name) for name in self.property_names)\n\n else:\n # ALL\n result = all(not _is_ref_prop(name) for name in self.property_names)\n\n return result","def is_relational(*args):\n return _ida_hexrays.is_relational(*args)","def check_rel(rel, rel_set):\n if rel is None:\n return False\n if isinstance(rel, tuple):\n return check_rel(rel[0], rel_set)\n if isinstance(rel, string_types):\n return rel.lower() in rel_set\n raise TypeError(\"Unsupported type {} of relation {!r}.\".format(\n type(rel), rel))","def test_cli_validate_with_invalid_check_relations():\n result = CliRunner().invoke(\n cli.cli,\n [\n \"validate\",\n \"tests/data/invalid-relations/datapackage.json\",\n \"--check-relations\",\n ],\n )\n assert result.exit_code == 0\n assert '\"valid\": true' in result.output\n assert \"Foreign key\" in result.output","def _check_duplicate_trans(self):\n transactions_set = set(self._transactions)\n return len(transactions_set) == len(self._transactions)","def hasConflicts(self):\n partners = {}\n for first, second in self:\n #print >>sys.stderr, \"first:\", first, \"second:\", second\n if first is None:\n if second is None:\n continue #no pairing info\n else:\n first, second = second, first #swap order so None is 2nd\n if second is None: #check first isn't paired\n if partners.get(first, None) is not None:\n print >>sys.stderr, \"here1\"\n print >>sys.stderr, \"first:\", first, \"second:\", second\n return True\n else:\n partners[first] = None\n else: #first and second were both non-empty: check partners\n if first in partners:\n if partners[first] != second:\n print >>sys.stderr, \"here2\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[first]\", partners[first]\n print \"partners:\", partners\n return True\n if second in partners:\n if partners[second] != first:\n print >>sys.stderr, \"here3\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[second]:\", partners[second]\n return True\n #add current pair to the list of constraints\n partners[first] = second\n partners[second] = first\n #can only get here if there weren't conflicts\n return False","def valid(self):\n return len(self._totals_) <= 1","def test_incoming_conceptional_relations(id, conrel, expected_ids):\n synset = germanet_data.get_synset_by_id(id)\n related = synset.incoming_relations[conrel]\n np.testing.assert_equal(sorted([syn.id for syn in related]), sorted(expected_ids))","def relation_exists(cls, model):\n return bool(cls.get_related_field(model)\n or cls.get_reverse_related_field(model))","def valid(self):\n return len(self.missing()) == 0","def checkIncToSets(_session, _el, _sets, _arc_type):\n for set in _sets:\n if _session.search_one_shot(_session.sc_constraint_new(sc_constants.CONSTR_3_f_a_f,\n set,\n sc.SC_ARC | _arc_type,\n _el), True, 3) is None:\n return False\n \n return True","def is_id(self):\n found = False\n for p in self.ant:\n for prop in self.con:\n if p == prop:\n found = True\n return found","def isRelational(self):\n return _libsbml.ASTNode_isRelational(self)","def is_contradiction(formula: Formula) -> bool:\n # Task 2.5b\n return not is_satisfiable(formula)","def is_contradiction(formula: Formula) -> bool:\r\n # Task 2.5b\r\n return not is_satisfiable(formula)","def get_sharp_relations_for_sets(follows, set_1, set_2):\n for item_1 in set_1:\n for item_2 in set_2:\n if not get_sharp_relation(follows, item_1, item_2):\n return False\n return True","def isValid(self):\n errorList = self.getErrors()\n\n return not errorList","def check_for_diaries():\n if len(DiaryModel.diary) >=1:\n return (len(DiaryModel.diary))","def consistent(self,assignment):\n return all(con.holds(assignment)\n for con in self.constraints\n if all(v in assignment for v in con.scope))","def is_disjoint(self, other):\n if not isinstance(other, SetPy):\n raise TypeError(\"Can only be disjoint with another SetPy\")\n return set_combinations.SetIntersect(self, other).cardinality() == 0","def isSubRelation(self, rhs):\n return set(self.iteritems()).issubset(rhs.iteritems())","def product_dependencies_are_resolvable(self, product):\n for v in self['products']:\n for identifier in product['ids']:\n if identifier in map(lambda dep: dep['id'], v.get('dependencies', [])):\n return False\n return True","def _is_foreign_key(self, key):\n return self._in_keys(key, self._foreign_keys)","def _check_unique_insesitive(self, cr, uid, ids, context=None):\n for category in self.browse(cr, uid, ids, context=context):\n if len(self.search(cr, uid, [('name','=ilike',category.name)], context=context)) > 1:\n raise osv.except_osv(_('Constraint Error'), _(\"The Name Must Be Unique!\"))\n return True","def test_cli_validate_with_valid_check_relations():\n result = CliRunner().invoke(\n cli.cli,\n [\n \"validate\",\n \"tests/data/valid-relations/datapackage.json\",\n \"--check-relations\",\n ],\n )\n assert result.exit_code == 0\n assert '\"valid\": true' in result.output","def _satisfied(self, cl, model):\n\n for l in cl:\n if len(model) < abs(l) or model[abs(l) - 1] == l:\n # either literal is unassigned or satisfied by the model\n return True\n\n return False","def __has_conflicting_node_names(self):\n # check length of sets to determine if overlap exists\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())","def valid_functionality(self, graph: Graph, fact: Tuple[str, str, str]) -> bool:\n similar_relation_exists = (fact[0], fact[1], None) in graph\n # increment the counter if a similar fact already exists (True -> +1, False -> +0)\n self.num_facts_violating_functionality += similar_relation_exists\n return not similar_relation_exists","def _valid_sbu_combination(self, incidence, sbu_set):\n if incidence is None:\n return len([i for i in sbu_set if i.is_metal]) == \\\n self.options.metal_sbu_per_structure\n else:\n if set(sorted([i.degree for i in sbu_set])) == set(sorted(incidence)):\n return len([i for i in sbu_set if i.is_metal]) == \\\n self.options.metal_sbu_per_structure\n else:\n return False","def _validate_relationships(cls, relationships: Dict) -> None:\n errors = []\n for name, rel_dict in relationships.items():\n if name not in cls.__relationships_fields_set__:\n errors.append(f\" '{name}' is not a valid relationship.\")\n if (rel_dict.get(\"links\") is None and rel_dict.get(\"data\")) is None:\n errors.append(\n f\" You must provide at least links or data for the '{name}' relationship.\"\n )\n if errors:\n raise ValueError(\"\\n\" + \"\\n\".join(errors))","def is_disjoint(self, other):\n return self.intersect(other) == S.EmptySet","def antecedants_matched(self, datacase):\n for item in self.cond_set:\n if datacase[item] != self.cond_set[item]:\n return False\n return True","def areResonancesProchiral(resonanceA, resonanceB):\n\n if resonanceA.resonanceSet:\n if resonanceB.resonanceSet:\n atomA = resonanceA.resonanceSet.findFirstAtomSet().findFirstAtom()\n atomB = resonanceB.resonanceSet.findFirstAtomSet().findFirstAtom()\n \n residueA = atomA.residue\n residueB = atomB.residue\n \n if residueA is residueB:\n chemAtomSetA = atomA.chemAtom.chemAtomSet\n chemAtomSetB = atomB.chemAtom.chemAtomSet\n\n if chemAtomSetA and (chemAtomSetA is chemAtomSetB):\n return True\n \n return False","def has_relation(\n self, source: Tuple[str, str], target: Tuple[str, str], relation: str\n ) -> bool:\n res = self.get_relations(source, target, relation, limit=1)\n if res:\n return True\n else:\n return False","def _has_needs_correcting(self, dframe):\n return (dframe.loc[dframe.sync_status == int(ConsentSyncStatus.NEEDS_CORRECTING)].shape[0] > 0)","def satisfies(self, other): # type: (Term) -> bool\n return (\n self._package == other.package\n and self.relation(other) == SetRelation.SUBSET\n )","def validate(self, fgraph):\r\n\r\n if self.destroyers:\r\n ords = self.orderings(fgraph)\r\n\r\n if _contains_cycle(fgraph, ords):\r\n raise InconsistencyError(\"Dependency graph contains cycles\")\r\n else:\r\n #James's Conjecture:\r\n #If there are no destructive ops, then there can be no cycles.\r\n pass\r\n return True","def hasNoDoubleVertices(self):\n assert all(self.vertices.count(v) == 1 for v in self.vertices)\n return (all(all(v1 == v2 or v1.dist(v2) > COMPARISON_EPSILON for v2 in self.vertices)\n for v1 in self.vertices) and\n all(self.vertices.count(v) == 1 for v in self.vertices))","def validate(self, fgraph):\r\n\r\n if self.destroyers:\r\n ords = self.orderings(fgraph)\r\n\r\n if _contains_cycle(fgraph, ords):\r\n raise InconsistencyError(\"Dependency graph contains cycles\")\r\n else:\r\n #James's Conjecture:\r\n #If there are no destructive ops, then there can be no cycles.\r\n pass\r\n return True","def allConstraintsSatisfied(self):\n # loop through all of the constraints\n for constraint in self.constraints:\n # if any of the constraints are not satisfied, then return False\n if (not constraint.satisfied(constraint.tail.value, constraint.head.value)):\n return False\n # no violations, so return true\n return True","def _ok(self, assignment_graph, source, value, target):\n target_values = assignment_graph[target]\n return len(target_values - set([value])) > 0","def violated(self) -> bool:\n ...","def isRelational(self, *args):\n return _libsbml.ASTBasePlugin_isRelational(self, *args)","def isChainAssigned(chain):\n\n for residue in chain.residues:\n for atom in residue.atoms:\n if atom.atomSet:\n if atom.atomSet.resonanceSets:\n return True\n \n return False","def is_proper(i0, i1, i2, i3, bond_set):\n if (i0, i1) in bond_set and (i1, i2) in bond_set and (i2, i3) in bond_set and len(set([i0, i1, i2, i3])) == 4:\n return True\n return False","def is_fuzzy_equivalence(fuzzy_set):\n\tif not is_symmetric(fuzzy_set):\n\t\treturn False\n\tif not is_reflexive(fuzzy_set):\n\t\treturn False\n\tif not is_max_min_transitive(fuzzy_set):\n\t\treturn False\n\treturn True","def _assert_record_relations(record, expected):\n relations_metadata = record.get(\"relations_metadata\", {})\n expected_metadata = expected.get(\"relations_metadata\", {})\n\n relations = record.get(\"relations\", {})\n expected_relations = expected.get(\"relations\", {})\n\n assert relations_metadata.keys() == expected_metadata.keys()\n for relation, records in relations_metadata.items():\n assert len(records) == len(expected_metadata[relation])\n for rec in records:\n assert rec in expected_metadata[relation]\n assert relations.keys() == expected_relations.keys()\n for relation, records in relations.items():\n assert len(records) == len(expected_relations[relation])\n for rec in records:\n assert rec in expected_relations[relation]","def isResidueAssigned(residue):\n\n for atom in residue.atoms:\n if atom.atomSet:\n if atom.atomSet.resonanceSets:\n return True\n \n return False","def is_exist_another_solution(self):\r\n # prepare data\r\n notes_quantity_min = sum(self.banknote_quantity)\r\n banknote_quantity_max = [int(math.floor(self.money / self.banknotes[i])) for i in range(0, self.n)]\r\n # model\r\n mdl = Model(name='MinSetChecker')\r\n # decision variables\r\n mdl.banknote_quantity = {i: mdl.integer_var(lb=0, ub=banknote_quantity_max[i]) for i in range(0, self.n)}\r\n # decision expressions\r\n money_amount = mdl.sum(mdl.banknote_quantity[i] * self.banknotes[i] for i in range(0, self.n))\r\n notes_quantity = mdl.sum(mdl.banknote_quantity[i] for i in range(0, self.n))\r\n # constraints\r\n mdl.add_constraint(money_amount == self.money)\r\n mdl.add_constraint(notes_quantity == notes_quantity_min)\r\n mdl.add_constraint(\r\n mdl.sum(mdl.banknote_quantity[i] == self.banknote_quantity[i] for i in range(0, self.n)) != self.n\r\n )\r\n # solve model: return True if it exists, False if not\r\n if not mdl.solve():\r\n return False\r\n else:\r\n return True","def _check_resident_matching(self):\n\n errors = []\n for resident in self.residents:\n if (\n resident.matching is not None\n and resident.matching not in resident.prefs\n ):\n errors.append(\n ValueError(\n f\"{resident} is matched to {resident.matching} but \"\n \"they do not appear in their preference list: \"\n f\"{resident.prefs}.\"\n )\n )\n\n if errors:\n raise Exception(*errors)\n\n return True","def has_mismatch(self) -> bool:\n return self.mismatch_error is not None","def allow_relation(self, obj1, obj2, **hints):\n if obj1._meta.app_label == 'data_collection' or \\\n obj2._meta.app_label == 'data_collection':\n return True\n return None","def is_U_times_relation(fuzzy_set):\n\tfor element in fuzzy_set.domain.domain_elements:\n\t\t# checking if every element is a tuple of length 2\n\t\tif not (isinstance(element, tuple) and len(element) == 2):\n\t\t\treturn False\n\t# checking if both domains that consists CompositeDomain contain the same domain_elements\n\t# (we already know that fuzzy_set.domain.list_of_domains contains only two elements\n\t# because we checked it in the first condition above)\n\tif fuzzy_set.domain.list_of_domains[0].domain_elements != fuzzy_set.domain.list_of_domains[1].domain_elements:\n\t\treturn False\n\treturn True","def check_cons(term, cons):\n res = True\n for constr in cons:\n if constr.issubset(term):\n res = False\n break\n return res","def are_pairwise_disjoint(it, raise_error=False):\n all_elements = set()\n for (i, l) in enumerate(it):\n s = set(l)\n if all_elements.isdisjoint(s):\n all_elements = all_elements.union(s)\n else:\n if raise_error:\n raise ValueError('Set at index {} is not disjoint with'\n 'previous sets. Common entries are {}'.\n format(i, all_elements.intersection(s)))\n return False\n\n return True","def validate_relation_data(self, sentry_unit, relation, expected):\n actual = sentry_unit.relation(relation[0], relation[1])\n self.log.debug('actual: {}'.format(repr(actual)))\n return self._validate_dict_data(expected, actual)","def validate(self) -> None:\n present_resource_ids = {resource.resource_id for resource in self.resources}\n resource_ref_ids_used_by_ids: DefaultDict[str, List[str]] = defaultdict(list)\n for resource in self.resources:\n for link in resource.links:\n if isinstance(link, ResourceLinkLink):\n resource_ref_ids_used_by_ids[link.obj].append(resource.resource_id)\n resource_ref_ids = set(resource_ref_ids_used_by_ids.keys())\n orphan_refs = resource_ref_ids - present_resource_ids\n if orphan_refs:\n raise GraphSetOrphanedReferencesException(\n (\"References to resources were found which were not scanned: \" f\"{orphan_refs}.\")\n )","def test_that_all_m2m_are_set(self):\n m2m_forgotten = 0\n for int_model in self.get_intermediate_models():\n fks = self.get_foreign_keys(int_model)\n models = self.presume_models_used_by_m2m(fks)\n for model1, model2 in itertools.combinations(models, 2):\n if not self.is_m2m_set(int_model, model1, model2):\n m2m_forgotten += 1\n self.assertEqual(m2m_forgotten, 0)","def _valid_bond_pair(self, set):\n (sbu1, cp1), (sbu2, cp2) = set\n if all([i is None for i in [cp1.special, cp2.special, cp1.constraint, cp2.constraint]]):\n return sbu1.is_metal != sbu2.is_metal\n\n return (cp1.special == cp2.constraint) and (cp2.special == cp1.constraint)","def exists(self):\n return len(list(self.measures)) > 0","def an_check(self):\n\t\tfor filles in self.xelt:\n\t\t\t# parcours rapide des branches niveau 1\n\t\t\tif search(r'analytic$', filles.tag):\n\t\t\t\treturn True\n\t\treturn False","def disjoint(self, other): # -> bool:\n ...","def has_exclusive_attributes(self):\n return any(schema.is_exclusive for schema in itervalues(self.schema))","def is_complete(self, A, B):\n return all(self.is_edge(v, w) for v in A for w in B)","def _degree_has_changed(first, second):\n return len(set(first) ^ set(second)) != 0","def _referencedChecker(self, entity, params):\n\n if 'ref_logic' not in params:\n return False\n\n logic = self.helper.getLogicForItem(params, 'ref_logic')\n filter = {\n params['ref_field']: entity.key()\n }\n ref_entity = logic.getForFields(filter=filter, unique=True)\n\n result = ref_entity is not None\n\n no_ref = params.get('no_ref')\n if no_ref:\n result = not result\n\n return result","def _check_hospital_matching(self):\n\n errors = []\n for hospital in self.hospitals:\n for resident in hospital.matching:\n if resident not in hospital.prefs:\n errors.append(\n ValueError(\n f\"{hospital} has {resident} in their matching but \"\n \"they do not appear in their preference list: \"\n f\"{hospital.prefs}.\"\n )\n )\n\n if errors:\n raise Exception(*errors)\n\n return True","def has_at_least_one_valid_answer(t_qid):\n answer_obj = self.getAnsObj(t_qid)\n answer_list = [ans['answer'] for ans in answer_obj]\n for ans in answer_list:\n if ans in self.adict:\n return True\n return False","def allow_relation(self, obj1, obj2, **hints):\n return self._route_by_model_type(obj1) == self._route_by_model_type(obj2)","def is_conflicting_keys(cls, d1, d2):\n return bool(set(d1.keys()).intersection(set(d2.keys())))","def test_verify_all_dependencies(self):\n\n for condition in self.all_references():\n result = self.verify_dependencies(condition)\n\n if result:\n self.ill_defined[condition] = result\n else:\n self.well_defined.add(condition)\n\n return self.ill_defined","def satisfied(self):\n\n if self.var1.get_value() is None or self.var2.get_value() is None:\n return False\n\n return self.var1.get_value() != self.var2.get_value()","def isRelated(self):\n return len(self.user_storage.all()) > 0","def is_normal_triple(triples, is_relation_first=False):\r\n entities = set()\r\n for i, e in enumerate(triples):\r\n key = 0 if is_relation_first else 2\r\n if i % 3 != key:\r\n entities.add(e)\r\n return len(entities) == 2*len(triples)/3","def is_valid(self) -> bool:\n return all(\n (\n not self.author,\n self.unit,\n )\n )","def check_exhausted(self):\n if (\n not self.is_exhausted\n and len(self.forced) == len(self.values)\n and self.transition is not None\n ):\n if isinstance(self.transition, (Conclusion, Killed)):\n self.is_exhausted = True\n elif len(self.transition.children) == self.transition.max_children:\n self.is_exhausted = all(\n v.is_exhausted for v in self.transition.children.values()\n )\n return self.is_exhausted","def check_single_excitation(self):\n\n if len(self.exc_dict.keys()) != 1:\n return False\n for key in self.exc_dict.keys():\n if len(self.exc_dict[key]) != 1:\n return False\n return True","def does_contain(self, other):\n if len(self.reactants) != len(other.retrons):\n return False\n for mols in itertools.permutations(self.reactants):\n if all(m.HasSubstructMatch(p)\n for m, p in zip(mols, other.retrons)):\n return True\n return False","def is_key_failure(e: sqlite3.IntegrityError) -> bool:\n return str(e) == \"FOREIGN KEY constraint failed\"","def has_relationship(self, relationship):\n return relationship in self._relationshipsDef","def valid(self):\n\t\tfor k, v in self.rules.items():\n\t\t\tfor i in v:\n\t\t\t\tif any([self.valid_rule_1(i), self.valid_rule_2(i), self.valid_rule_3(k, i)]):\n\t\t\t\t\t# print(\"Got a pass\")\n\t\t\t\t\tpass\n\t\t\t\telse:\n\t\t\t\t\t# print(\"Got a fail\")\n\t\t\t\t\treturn False\n\t\t# print(\"CORRECT CFG\")\n\t\treturn True","def test_(schema, schemas, expected_valid):\n name = \"Schema\"\n association = association_helper.TParentPropertySchema(\n parent=types.TNameSchema(name=\"ParentSchema\", schema={}),\n property=types.TNameSchema(name=\"PropertySchema\", schema={}),\n )\n\n returned_result = validation.association._check_2_or_fewer_primary_key(\n name=name, schema=schema, association=association, schemas=schemas\n )\n\n assert returned_result.valid == expected_valid\n if not expected_valid:\n expected_reasons = (\n name,\n association.parent.name,\n association.property.name,\n \"too many\",\n \"primary key\",\n )\n\n for reason in expected_reasons:\n assert reason in returned_result.reason","def valid_chain(chain):\n\n for i in range(len(chain) - 1):\n parent_edge = chain[i]\n child_edge = chain[i + 1]\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\n if not parent_edge[1] == child_edge[0]:\n # if this isn't\n return False\n return True"],"string":"[\n \"def check_relations(self, relations):\\n if self.debug:\\n print(\\\"Checking relations\\\")\\n result = False\\n work_relations = []\\n\\n # Eliminate unnecessary(duplicated) clauses\\n if relations[\\\"is_derived_from\\\"]:\\n relations[\\\"has_derived_form\\\"] = True\\n relations[\\\"is_derived_from\\\"] = False\\n if relations[\\\"etymology\\\"]:\\n relations[\\\"etymological_origin_of\\\"] = True\\n relations[\\\"etymology\\\"] = False\\n\\n for relation in relations:\\n if relations[relation]:\\n result = True\\n work_relations.append(relation)\\n return result, work_relations\",\n \"def _relation_check(self):\\n seen = set()\\n for entity in self.get_entities():\\n for field in entity.fields.itervalues():\\n if field.is_relation():\\n seen.add(field.remote_name)\\n missing = seen - set(self.entities.keys())\\n if missing:\\n raise exceptions.SchemaError(\\n 'undefined entities referenced in relations: %s' % (\\n ', '.join(missing)))\",\n \"def test_conceptional_relations(id, conrel, expected_ids):\\n synset = germanet_data.get_synset_by_id(id)\\n related = synset.relations[conrel]\\n np.testing.assert_equal(sorted([syn.id for syn in related]), sorted(expected_ids))\",\n \"def has_conflict(self):\\n for diffstat in self.diffstat():\\n if diffstat.has_conflict:\\n return True\\n return False\",\n \"def pair_has_contradiction(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n return relation_set_has_contradictions(relations)\",\n \"def can_create_relation(self, rids):\\n if len(rids) < 2:\\n raise ValueError(\\\"It takes at least 2 to tango!\\\")\\n rids = tuple(rids)\\n existing = self.find_relations(rids[0], *rids[1:])\\n if existing:\\n cmp_set = set(rids)\\n for rel_id in existing:\\n if self.get(rel_id) == cmp_set:\\n raise ValueError(\\\"Already has relations: %s\\\" % \\\", \\\".join(existing))\",\n \"def is_equivalence(self) -> bool:\",\n \"def exact_fact_check(self, triple, transitive=False):\\n exists = self.knowledge_graph.check_triple_object_existence(triple, transitive)\\n if exists is True:\\n return 'exists', []\\n conflicts = self.knowledge_graph.get_triples(triple.subject, triple.relation, transitive)\\n if conflicts is not None:\\n return 'conflicts', conflicts\\n # The following checks triples with the same subject and object, but different relation. Are those conflict?\\n # if conflicts is None:\\n # conflicts = []\\n # for obj in triple.objects:\\n # relations = self.knowledge_graph.get_relation_triples(triple.subject, obj)\\n # if relations is not None:\\n # conflicts += relations\\n # if len(conflicts) > 0:\\n # return 'conflicts', conflicts\\n return 'none', []\",\n \"def consistent(self):\\n return all((constraint.consistent() for constraint in self.constraints))\",\n \"def is_relation(self, rel_name):\\n return rel_name in self._declaration\",\n \"def is_consistent(self, constraints):\\n for constraint in constraints:\\n if not constraint.is_satisfied_with(self):\\n return False\\n return True\",\n \"def is_reflexive(fuzzy_set):\\n\\tfor index, element in enumerate(fuzzy_set.domain.domain_elements):\\n\\t\\tif element[0] == element[1]:\\n\\t\\t\\tif not fuzzy_set.memberships[index] == 1:\\n\\t\\t\\t\\treturn False\\n\\treturn True\",\n \"def author_ManyToMany_entry_check(): #Old it was OneToMany before adding multiple authors\\n import itertools\\n entry_author_ids = itertools.chain(*Entry.objects.all().values_list('author_ids', flat=True))\\n entry_author_ids_set = set(entry_author_ids)\\n user_ids = set(User.objects.all().values_list('id',flat=True))\\n\\n author_id_not_in_user = entry_author_ids_set - user_ids\\n\\n if author_id_not_in_user:\\n return (\\\"Error: There are entries without a correct cross relation with user: {}\\\"\\n .format(\\\",\\\".join(str(s) for s in author_id_not_in_user)))\\n else:\\n return \\\"OK\\\"\",\n \"def complete(self):\\n return all((constraint.satisfied() for constraint in self.constraints))\",\n \"def __has_multiple_edges(self):\\n return \\\\\\n len(\\n list(\\n [\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n ] # the length of the list which allows duplicates...\\n )\\n ) != \\\\\\n len(\\n set(\\n {\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n } # ...should equal the length of the set that does not allow duplicates\\n )\\n ) # return True if the two data structures are equal in size and False otherwise\",\n \"def __has_no_dependents (self, obj, constraints):\\n failed = False\\n while constraints and not failed:\\n c = constraints [0]\\n\\n if c [1] == obj:\\n failed = True\\n\\n constraints = constraints [1:]\\n\\n return not failed\",\n \"def check_membership(self, ref_set, my_set):\\n rset = set(ref_set)\\n mset = set(my_set)\\n if len(rset.intersection(mset)) > 0:\\n return 1\\n else:\\n return 0\",\n \"def can_satisfy_without_refs(self):\\n\\n if self.constraint_type in (self.ONE, self.AT_LEAST_ONE):\\n result = any(not _is_ref_prop(name) for name in self.property_names)\\n\\n else:\\n # ALL\\n result = all(not _is_ref_prop(name) for name in self.property_names)\\n\\n return result\",\n \"def is_relational(*args):\\n return _ida_hexrays.is_relational(*args)\",\n \"def check_rel(rel, rel_set):\\n if rel is None:\\n return False\\n if isinstance(rel, tuple):\\n return check_rel(rel[0], rel_set)\\n if isinstance(rel, string_types):\\n return rel.lower() in rel_set\\n raise TypeError(\\\"Unsupported type {} of relation {!r}.\\\".format(\\n type(rel), rel))\",\n \"def test_cli_validate_with_invalid_check_relations():\\n result = CliRunner().invoke(\\n cli.cli,\\n [\\n \\\"validate\\\",\\n \\\"tests/data/invalid-relations/datapackage.json\\\",\\n \\\"--check-relations\\\",\\n ],\\n )\\n assert result.exit_code == 0\\n assert '\\\"valid\\\": true' in result.output\\n assert \\\"Foreign key\\\" in result.output\",\n \"def _check_duplicate_trans(self):\\n transactions_set = set(self._transactions)\\n return len(transactions_set) == len(self._transactions)\",\n \"def hasConflicts(self):\\n partners = {}\\n for first, second in self:\\n #print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n if first is None:\\n if second is None:\\n continue #no pairing info\\n else:\\n first, second = second, first #swap order so None is 2nd\\n if second is None: #check first isn't paired\\n if partners.get(first, None) is not None:\\n print >>sys.stderr, \\\"here1\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n return True\\n else:\\n partners[first] = None\\n else: #first and second were both non-empty: check partners\\n if first in partners:\\n if partners[first] != second:\\n print >>sys.stderr, \\\"here2\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[first]\\\", partners[first]\\n print \\\"partners:\\\", partners\\n return True\\n if second in partners:\\n if partners[second] != first:\\n print >>sys.stderr, \\\"here3\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[second]:\\\", partners[second]\\n return True\\n #add current pair to the list of constraints\\n partners[first] = second\\n partners[second] = first\\n #can only get here if there weren't conflicts\\n return False\",\n \"def valid(self):\\n return len(self._totals_) <= 1\",\n \"def test_incoming_conceptional_relations(id, conrel, expected_ids):\\n synset = germanet_data.get_synset_by_id(id)\\n related = synset.incoming_relations[conrel]\\n np.testing.assert_equal(sorted([syn.id for syn in related]), sorted(expected_ids))\",\n \"def relation_exists(cls, model):\\n return bool(cls.get_related_field(model)\\n or cls.get_reverse_related_field(model))\",\n \"def valid(self):\\n return len(self.missing()) == 0\",\n \"def checkIncToSets(_session, _el, _sets, _arc_type):\\n for set in _sets:\\n if _session.search_one_shot(_session.sc_constraint_new(sc_constants.CONSTR_3_f_a_f,\\n set,\\n sc.SC_ARC | _arc_type,\\n _el), True, 3) is None:\\n return False\\n \\n return True\",\n \"def is_id(self):\\n found = False\\n for p in self.ant:\\n for prop in self.con:\\n if p == prop:\\n found = True\\n return found\",\n \"def isRelational(self):\\n return _libsbml.ASTNode_isRelational(self)\",\n \"def is_contradiction(formula: Formula) -> bool:\\n # Task 2.5b\\n return not is_satisfiable(formula)\",\n \"def is_contradiction(formula: Formula) -> bool:\\r\\n # Task 2.5b\\r\\n return not is_satisfiable(formula)\",\n \"def get_sharp_relations_for_sets(follows, set_1, set_2):\\n for item_1 in set_1:\\n for item_2 in set_2:\\n if not get_sharp_relation(follows, item_1, item_2):\\n return False\\n return True\",\n \"def isValid(self):\\n errorList = self.getErrors()\\n\\n return not errorList\",\n \"def check_for_diaries():\\n if len(DiaryModel.diary) >=1:\\n return (len(DiaryModel.diary))\",\n \"def consistent(self,assignment):\\n return all(con.holds(assignment)\\n for con in self.constraints\\n if all(v in assignment for v in con.scope))\",\n \"def is_disjoint(self, other):\\n if not isinstance(other, SetPy):\\n raise TypeError(\\\"Can only be disjoint with another SetPy\\\")\\n return set_combinations.SetIntersect(self, other).cardinality() == 0\",\n \"def isSubRelation(self, rhs):\\n return set(self.iteritems()).issubset(rhs.iteritems())\",\n \"def product_dependencies_are_resolvable(self, product):\\n for v in self['products']:\\n for identifier in product['ids']:\\n if identifier in map(lambda dep: dep['id'], v.get('dependencies', [])):\\n return False\\n return True\",\n \"def _is_foreign_key(self, key):\\n return self._in_keys(key, self._foreign_keys)\",\n \"def _check_unique_insesitive(self, cr, uid, ids, context=None):\\n for category in self.browse(cr, uid, ids, context=context):\\n if len(self.search(cr, uid, [('name','=ilike',category.name)], context=context)) > 1:\\n raise osv.except_osv(_('Constraint Error'), _(\\\"The Name Must Be Unique!\\\"))\\n return True\",\n \"def test_cli_validate_with_valid_check_relations():\\n result = CliRunner().invoke(\\n cli.cli,\\n [\\n \\\"validate\\\",\\n \\\"tests/data/valid-relations/datapackage.json\\\",\\n \\\"--check-relations\\\",\\n ],\\n )\\n assert result.exit_code == 0\\n assert '\\\"valid\\\": true' in result.output\",\n \"def _satisfied(self, cl, model):\\n\\n for l in cl:\\n if len(model) < abs(l) or model[abs(l) - 1] == l:\\n # either literal is unassigned or satisfied by the model\\n return True\\n\\n return False\",\n \"def __has_conflicting_node_names(self):\\n # check length of sets to determine if overlap exists\\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())\",\n \"def valid_functionality(self, graph: Graph, fact: Tuple[str, str, str]) -> bool:\\n similar_relation_exists = (fact[0], fact[1], None) in graph\\n # increment the counter if a similar fact already exists (True -> +1, False -> +0)\\n self.num_facts_violating_functionality += similar_relation_exists\\n return not similar_relation_exists\",\n \"def _valid_sbu_combination(self, incidence, sbu_set):\\n if incidence is None:\\n return len([i for i in sbu_set if i.is_metal]) == \\\\\\n self.options.metal_sbu_per_structure\\n else:\\n if set(sorted([i.degree for i in sbu_set])) == set(sorted(incidence)):\\n return len([i for i in sbu_set if i.is_metal]) == \\\\\\n self.options.metal_sbu_per_structure\\n else:\\n return False\",\n \"def _validate_relationships(cls, relationships: Dict) -> None:\\n errors = []\\n for name, rel_dict in relationships.items():\\n if name not in cls.__relationships_fields_set__:\\n errors.append(f\\\" '{name}' is not a valid relationship.\\\")\\n if (rel_dict.get(\\\"links\\\") is None and rel_dict.get(\\\"data\\\")) is None:\\n errors.append(\\n f\\\" You must provide at least links or data for the '{name}' relationship.\\\"\\n )\\n if errors:\\n raise ValueError(\\\"\\\\n\\\" + \\\"\\\\n\\\".join(errors))\",\n \"def is_disjoint(self, other):\\n return self.intersect(other) == S.EmptySet\",\n \"def antecedants_matched(self, datacase):\\n for item in self.cond_set:\\n if datacase[item] != self.cond_set[item]:\\n return False\\n return True\",\n \"def areResonancesProchiral(resonanceA, resonanceB):\\n\\n if resonanceA.resonanceSet:\\n if resonanceB.resonanceSet:\\n atomA = resonanceA.resonanceSet.findFirstAtomSet().findFirstAtom()\\n atomB = resonanceB.resonanceSet.findFirstAtomSet().findFirstAtom()\\n \\n residueA = atomA.residue\\n residueB = atomB.residue\\n \\n if residueA is residueB:\\n chemAtomSetA = atomA.chemAtom.chemAtomSet\\n chemAtomSetB = atomB.chemAtom.chemAtomSet\\n\\n if chemAtomSetA and (chemAtomSetA is chemAtomSetB):\\n return True\\n \\n return False\",\n \"def has_relation(\\n self, source: Tuple[str, str], target: Tuple[str, str], relation: str\\n ) -> bool:\\n res = self.get_relations(source, target, relation, limit=1)\\n if res:\\n return True\\n else:\\n return False\",\n \"def _has_needs_correcting(self, dframe):\\n return (dframe.loc[dframe.sync_status == int(ConsentSyncStatus.NEEDS_CORRECTING)].shape[0] > 0)\",\n \"def satisfies(self, other): # type: (Term) -> bool\\n return (\\n self._package == other.package\\n and self.relation(other) == SetRelation.SUBSET\\n )\",\n \"def validate(self, fgraph):\\r\\n\\r\\n if self.destroyers:\\r\\n ords = self.orderings(fgraph)\\r\\n\\r\\n if _contains_cycle(fgraph, ords):\\r\\n raise InconsistencyError(\\\"Dependency graph contains cycles\\\")\\r\\n else:\\r\\n #James's Conjecture:\\r\\n #If there are no destructive ops, then there can be no cycles.\\r\\n pass\\r\\n return True\",\n \"def hasNoDoubleVertices(self):\\n assert all(self.vertices.count(v) == 1 for v in self.vertices)\\n return (all(all(v1 == v2 or v1.dist(v2) > COMPARISON_EPSILON for v2 in self.vertices)\\n for v1 in self.vertices) and\\n all(self.vertices.count(v) == 1 for v in self.vertices))\",\n \"def validate(self, fgraph):\\r\\n\\r\\n if self.destroyers:\\r\\n ords = self.orderings(fgraph)\\r\\n\\r\\n if _contains_cycle(fgraph, ords):\\r\\n raise InconsistencyError(\\\"Dependency graph contains cycles\\\")\\r\\n else:\\r\\n #James's Conjecture:\\r\\n #If there are no destructive ops, then there can be no cycles.\\r\\n pass\\r\\n return True\",\n \"def allConstraintsSatisfied(self):\\n # loop through all of the constraints\\n for constraint in self.constraints:\\n # if any of the constraints are not satisfied, then return False\\n if (not constraint.satisfied(constraint.tail.value, constraint.head.value)):\\n return False\\n # no violations, so return true\\n return True\",\n \"def _ok(self, assignment_graph, source, value, target):\\n target_values = assignment_graph[target]\\n return len(target_values - set([value])) > 0\",\n \"def violated(self) -> bool:\\n ...\",\n \"def isRelational(self, *args):\\n return _libsbml.ASTBasePlugin_isRelational(self, *args)\",\n \"def isChainAssigned(chain):\\n\\n for residue in chain.residues:\\n for atom in residue.atoms:\\n if atom.atomSet:\\n if atom.atomSet.resonanceSets:\\n return True\\n \\n return False\",\n \"def is_proper(i0, i1, i2, i3, bond_set):\\n if (i0, i1) in bond_set and (i1, i2) in bond_set and (i2, i3) in bond_set and len(set([i0, i1, i2, i3])) == 4:\\n return True\\n return False\",\n \"def is_fuzzy_equivalence(fuzzy_set):\\n\\tif not is_symmetric(fuzzy_set):\\n\\t\\treturn False\\n\\tif not is_reflexive(fuzzy_set):\\n\\t\\treturn False\\n\\tif not is_max_min_transitive(fuzzy_set):\\n\\t\\treturn False\\n\\treturn True\",\n \"def _assert_record_relations(record, expected):\\n relations_metadata = record.get(\\\"relations_metadata\\\", {})\\n expected_metadata = expected.get(\\\"relations_metadata\\\", {})\\n\\n relations = record.get(\\\"relations\\\", {})\\n expected_relations = expected.get(\\\"relations\\\", {})\\n\\n assert relations_metadata.keys() == expected_metadata.keys()\\n for relation, records in relations_metadata.items():\\n assert len(records) == len(expected_metadata[relation])\\n for rec in records:\\n assert rec in expected_metadata[relation]\\n assert relations.keys() == expected_relations.keys()\\n for relation, records in relations.items():\\n assert len(records) == len(expected_relations[relation])\\n for rec in records:\\n assert rec in expected_relations[relation]\",\n \"def isResidueAssigned(residue):\\n\\n for atom in residue.atoms:\\n if atom.atomSet:\\n if atom.atomSet.resonanceSets:\\n return True\\n \\n return False\",\n \"def is_exist_another_solution(self):\\r\\n # prepare data\\r\\n notes_quantity_min = sum(self.banknote_quantity)\\r\\n banknote_quantity_max = [int(math.floor(self.money / self.banknotes[i])) for i in range(0, self.n)]\\r\\n # model\\r\\n mdl = Model(name='MinSetChecker')\\r\\n # decision variables\\r\\n mdl.banknote_quantity = {i: mdl.integer_var(lb=0, ub=banknote_quantity_max[i]) for i in range(0, self.n)}\\r\\n # decision expressions\\r\\n money_amount = mdl.sum(mdl.banknote_quantity[i] * self.banknotes[i] for i in range(0, self.n))\\r\\n notes_quantity = mdl.sum(mdl.banknote_quantity[i] for i in range(0, self.n))\\r\\n # constraints\\r\\n mdl.add_constraint(money_amount == self.money)\\r\\n mdl.add_constraint(notes_quantity == notes_quantity_min)\\r\\n mdl.add_constraint(\\r\\n mdl.sum(mdl.banknote_quantity[i] == self.banknote_quantity[i] for i in range(0, self.n)) != self.n\\r\\n )\\r\\n # solve model: return True if it exists, False if not\\r\\n if not mdl.solve():\\r\\n return False\\r\\n else:\\r\\n return True\",\n \"def _check_resident_matching(self):\\n\\n errors = []\\n for resident in self.residents:\\n if (\\n resident.matching is not None\\n and resident.matching not in resident.prefs\\n ):\\n errors.append(\\n ValueError(\\n f\\\"{resident} is matched to {resident.matching} but \\\"\\n \\\"they do not appear in their preference list: \\\"\\n f\\\"{resident.prefs}.\\\"\\n )\\n )\\n\\n if errors:\\n raise Exception(*errors)\\n\\n return True\",\n \"def has_mismatch(self) -> bool:\\n return self.mismatch_error is not None\",\n \"def allow_relation(self, obj1, obj2, **hints):\\n if obj1._meta.app_label == 'data_collection' or \\\\\\n obj2._meta.app_label == 'data_collection':\\n return True\\n return None\",\n \"def is_U_times_relation(fuzzy_set):\\n\\tfor element in fuzzy_set.domain.domain_elements:\\n\\t\\t# checking if every element is a tuple of length 2\\n\\t\\tif not (isinstance(element, tuple) and len(element) == 2):\\n\\t\\t\\treturn False\\n\\t# checking if both domains that consists CompositeDomain contain the same domain_elements\\n\\t# (we already know that fuzzy_set.domain.list_of_domains contains only two elements\\n\\t# because we checked it in the first condition above)\\n\\tif fuzzy_set.domain.list_of_domains[0].domain_elements != fuzzy_set.domain.list_of_domains[1].domain_elements:\\n\\t\\treturn False\\n\\treturn True\",\n \"def check_cons(term, cons):\\n res = True\\n for constr in cons:\\n if constr.issubset(term):\\n res = False\\n break\\n return res\",\n \"def are_pairwise_disjoint(it, raise_error=False):\\n all_elements = set()\\n for (i, l) in enumerate(it):\\n s = set(l)\\n if all_elements.isdisjoint(s):\\n all_elements = all_elements.union(s)\\n else:\\n if raise_error:\\n raise ValueError('Set at index {} is not disjoint with'\\n 'previous sets. Common entries are {}'.\\n format(i, all_elements.intersection(s)))\\n return False\\n\\n return True\",\n \"def validate_relation_data(self, sentry_unit, relation, expected):\\n actual = sentry_unit.relation(relation[0], relation[1])\\n self.log.debug('actual: {}'.format(repr(actual)))\\n return self._validate_dict_data(expected, actual)\",\n \"def validate(self) -> None:\\n present_resource_ids = {resource.resource_id for resource in self.resources}\\n resource_ref_ids_used_by_ids: DefaultDict[str, List[str]] = defaultdict(list)\\n for resource in self.resources:\\n for link in resource.links:\\n if isinstance(link, ResourceLinkLink):\\n resource_ref_ids_used_by_ids[link.obj].append(resource.resource_id)\\n resource_ref_ids = set(resource_ref_ids_used_by_ids.keys())\\n orphan_refs = resource_ref_ids - present_resource_ids\\n if orphan_refs:\\n raise GraphSetOrphanedReferencesException(\\n (\\\"References to resources were found which were not scanned: \\\" f\\\"{orphan_refs}.\\\")\\n )\",\n \"def test_that_all_m2m_are_set(self):\\n m2m_forgotten = 0\\n for int_model in self.get_intermediate_models():\\n fks = self.get_foreign_keys(int_model)\\n models = self.presume_models_used_by_m2m(fks)\\n for model1, model2 in itertools.combinations(models, 2):\\n if not self.is_m2m_set(int_model, model1, model2):\\n m2m_forgotten += 1\\n self.assertEqual(m2m_forgotten, 0)\",\n \"def _valid_bond_pair(self, set):\\n (sbu1, cp1), (sbu2, cp2) = set\\n if all([i is None for i in [cp1.special, cp2.special, cp1.constraint, cp2.constraint]]):\\n return sbu1.is_metal != sbu2.is_metal\\n\\n return (cp1.special == cp2.constraint) and (cp2.special == cp1.constraint)\",\n \"def exists(self):\\n return len(list(self.measures)) > 0\",\n \"def an_check(self):\\n\\t\\tfor filles in self.xelt:\\n\\t\\t\\t# parcours rapide des branches niveau 1\\n\\t\\t\\tif search(r'analytic$', filles.tag):\\n\\t\\t\\t\\treturn True\\n\\t\\treturn False\",\n \"def disjoint(self, other): # -> bool:\\n ...\",\n \"def has_exclusive_attributes(self):\\n return any(schema.is_exclusive for schema in itervalues(self.schema))\",\n \"def is_complete(self, A, B):\\n return all(self.is_edge(v, w) for v in A for w in B)\",\n \"def _degree_has_changed(first, second):\\n return len(set(first) ^ set(second)) != 0\",\n \"def _referencedChecker(self, entity, params):\\n\\n if 'ref_logic' not in params:\\n return False\\n\\n logic = self.helper.getLogicForItem(params, 'ref_logic')\\n filter = {\\n params['ref_field']: entity.key()\\n }\\n ref_entity = logic.getForFields(filter=filter, unique=True)\\n\\n result = ref_entity is not None\\n\\n no_ref = params.get('no_ref')\\n if no_ref:\\n result = not result\\n\\n return result\",\n \"def _check_hospital_matching(self):\\n\\n errors = []\\n for hospital in self.hospitals:\\n for resident in hospital.matching:\\n if resident not in hospital.prefs:\\n errors.append(\\n ValueError(\\n f\\\"{hospital} has {resident} in their matching but \\\"\\n \\\"they do not appear in their preference list: \\\"\\n f\\\"{hospital.prefs}.\\\"\\n )\\n )\\n\\n if errors:\\n raise Exception(*errors)\\n\\n return True\",\n \"def has_at_least_one_valid_answer(t_qid):\\n answer_obj = self.getAnsObj(t_qid)\\n answer_list = [ans['answer'] for ans in answer_obj]\\n for ans in answer_list:\\n if ans in self.adict:\\n return True\\n return False\",\n \"def allow_relation(self, obj1, obj2, **hints):\\n return self._route_by_model_type(obj1) == self._route_by_model_type(obj2)\",\n \"def is_conflicting_keys(cls, d1, d2):\\n return bool(set(d1.keys()).intersection(set(d2.keys())))\",\n \"def test_verify_all_dependencies(self):\\n\\n for condition in self.all_references():\\n result = self.verify_dependencies(condition)\\n\\n if result:\\n self.ill_defined[condition] = result\\n else:\\n self.well_defined.add(condition)\\n\\n return self.ill_defined\",\n \"def satisfied(self):\\n\\n if self.var1.get_value() is None or self.var2.get_value() is None:\\n return False\\n\\n return self.var1.get_value() != self.var2.get_value()\",\n \"def isRelated(self):\\n return len(self.user_storage.all()) > 0\",\n \"def is_normal_triple(triples, is_relation_first=False):\\r\\n entities = set()\\r\\n for i, e in enumerate(triples):\\r\\n key = 0 if is_relation_first else 2\\r\\n if i % 3 != key:\\r\\n entities.add(e)\\r\\n return len(entities) == 2*len(triples)/3\",\n \"def is_valid(self) -> bool:\\n return all(\\n (\\n not self.author,\\n self.unit,\\n )\\n )\",\n \"def check_exhausted(self):\\n if (\\n not self.is_exhausted\\n and len(self.forced) == len(self.values)\\n and self.transition is not None\\n ):\\n if isinstance(self.transition, (Conclusion, Killed)):\\n self.is_exhausted = True\\n elif len(self.transition.children) == self.transition.max_children:\\n self.is_exhausted = all(\\n v.is_exhausted for v in self.transition.children.values()\\n )\\n return self.is_exhausted\",\n \"def check_single_excitation(self):\\n\\n if len(self.exc_dict.keys()) != 1:\\n return False\\n for key in self.exc_dict.keys():\\n if len(self.exc_dict[key]) != 1:\\n return False\\n return True\",\n \"def does_contain(self, other):\\n if len(self.reactants) != len(other.retrons):\\n return False\\n for mols in itertools.permutations(self.reactants):\\n if all(m.HasSubstructMatch(p)\\n for m, p in zip(mols, other.retrons)):\\n return True\\n return False\",\n \"def is_key_failure(e: sqlite3.IntegrityError) -> bool:\\n return str(e) == \\\"FOREIGN KEY constraint failed\\\"\",\n \"def has_relationship(self, relationship):\\n return relationship in self._relationshipsDef\",\n \"def valid(self):\\n\\t\\tfor k, v in self.rules.items():\\n\\t\\t\\tfor i in v:\\n\\t\\t\\t\\tif any([self.valid_rule_1(i), self.valid_rule_2(i), self.valid_rule_3(k, i)]):\\n\\t\\t\\t\\t\\t# print(\\\"Got a pass\\\")\\n\\t\\t\\t\\t\\tpass\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t# print(\\\"Got a fail\\\")\\n\\t\\t\\t\\t\\treturn False\\n\\t\\t# print(\\\"CORRECT CFG\\\")\\n\\t\\treturn True\",\n \"def test_(schema, schemas, expected_valid):\\n name = \\\"Schema\\\"\\n association = association_helper.TParentPropertySchema(\\n parent=types.TNameSchema(name=\\\"ParentSchema\\\", schema={}),\\n property=types.TNameSchema(name=\\\"PropertySchema\\\", schema={}),\\n )\\n\\n returned_result = validation.association._check_2_or_fewer_primary_key(\\n name=name, schema=schema, association=association, schemas=schemas\\n )\\n\\n assert returned_result.valid == expected_valid\\n if not expected_valid:\\n expected_reasons = (\\n name,\\n association.parent.name,\\n association.property.name,\\n \\\"too many\\\",\\n \\\"primary key\\\",\\n )\\n\\n for reason in expected_reasons:\\n assert reason in returned_result.reason\",\n \"def valid_chain(chain):\\n\\n for i in range(len(chain) - 1):\\n parent_edge = chain[i]\\n child_edge = chain[i + 1]\\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\\n if not parent_edge[1] == child_edge[0]:\\n # if this isn't\\n return False\\n return True\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7122376","0.67345405","0.6449695","0.6206758","0.6205824","0.6188202","0.61652434","0.61545885","0.6087285","0.60733366","0.6025005","0.6013213","0.60035706","0.5984546","0.59587294","0.5939061","0.5924129","0.5839123","0.5822666","0.5814324","0.5813227","0.5801442","0.5782242","0.57773024","0.57684803","0.57624924","0.5761884","0.57327116","0.5720645","0.5710378","0.5706659","0.56850946","0.5682397","0.56684035","0.56682193","0.5663189","0.56339574","0.56307465","0.5617068","0.5611569","0.56057894","0.55990326","0.55757046","0.5571497","0.5565197","0.5561127","0.55554813","0.5549647","0.5540066","0.55261195","0.55099154","0.55078703","0.5503426","0.55005485","0.5493155","0.54924804","0.54838514","0.5482246","0.54717463","0.54705995","0.54693437","0.5463888","0.545449","0.5453345","0.5449503","0.54477054","0.5445076","0.5437698","0.5434907","0.5429207","0.5422401","0.54034907","0.5400563","0.5387345","0.53841245","0.5378454","0.537781","0.5373508","0.53716743","0.53703177","0.53661776","0.53620225","0.53569704","0.5354307","0.53534424","0.5352253","0.5345513","0.53437763","0.5340262","0.53322405","0.53278154","0.5322662","0.53208816","0.53207016","0.53205365","0.5318038","0.5317859","0.5316512","0.5315096","0.5312829"],"string":"[\n \"0.7122376\",\n \"0.67345405\",\n \"0.6449695\",\n \"0.6206758\",\n \"0.6205824\",\n \"0.6188202\",\n \"0.61652434\",\n \"0.61545885\",\n \"0.6087285\",\n \"0.60733366\",\n \"0.6025005\",\n \"0.6013213\",\n \"0.60035706\",\n \"0.5984546\",\n \"0.59587294\",\n \"0.5939061\",\n \"0.5924129\",\n \"0.5839123\",\n \"0.5822666\",\n \"0.5814324\",\n \"0.5813227\",\n \"0.5801442\",\n \"0.5782242\",\n \"0.57773024\",\n \"0.57684803\",\n \"0.57624924\",\n \"0.5761884\",\n \"0.57327116\",\n \"0.5720645\",\n \"0.5710378\",\n \"0.5706659\",\n \"0.56850946\",\n \"0.5682397\",\n \"0.56684035\",\n \"0.56682193\",\n \"0.5663189\",\n \"0.56339574\",\n \"0.56307465\",\n \"0.5617068\",\n \"0.5611569\",\n \"0.56057894\",\n \"0.55990326\",\n \"0.55757046\",\n \"0.5571497\",\n \"0.5565197\",\n \"0.5561127\",\n \"0.55554813\",\n \"0.5549647\",\n \"0.5540066\",\n \"0.55261195\",\n \"0.55099154\",\n \"0.55078703\",\n \"0.5503426\",\n \"0.55005485\",\n \"0.5493155\",\n \"0.54924804\",\n \"0.54838514\",\n \"0.5482246\",\n \"0.54717463\",\n \"0.54705995\",\n \"0.54693437\",\n \"0.5463888\",\n \"0.545449\",\n \"0.5453345\",\n \"0.5449503\",\n \"0.54477054\",\n \"0.5445076\",\n \"0.5437698\",\n \"0.5434907\",\n \"0.5429207\",\n \"0.5422401\",\n \"0.54034907\",\n \"0.5400563\",\n \"0.5387345\",\n \"0.53841245\",\n \"0.5378454\",\n \"0.537781\",\n \"0.5373508\",\n \"0.53716743\",\n \"0.53703177\",\n \"0.53661776\",\n \"0.53620225\",\n \"0.53569704\",\n \"0.5354307\",\n \"0.53534424\",\n \"0.5352253\",\n \"0.5345513\",\n \"0.53437763\",\n \"0.5340262\",\n \"0.53322405\",\n \"0.53278154\",\n \"0.5322662\",\n \"0.53208816\",\n \"0.53207016\",\n \"0.53205365\",\n \"0.5318038\",\n \"0.5317859\",\n \"0.5316512\",\n \"0.5315096\",\n \"0.5312829\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7635147"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20171,"cells":{"query":{"kind":"string","value":"Checks if a pair of nodes has any contradictions in their causal relationships."},"document":{"kind":"string","value":"def pair_has_contradiction(graph, u, v):\n relations = get_all_relations(graph, u, v)\n return relation_set_has_contradictions(relations)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def relation_set_has_contradictions(relations):\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\n return 1 < sum([has_cnc, has_decreases, has_increases])","def get_contradictory_pairs(graph):\n for u, v in _iter_pairs(graph):\n if pair_has_contradiction(graph, u, v):\n yield u, v","def is_contradiction_(transition):\n is_contr = False\n\n # check implications of lower left corner\n if np.argmax(transition[0]) == 0:\n if np.argmax(transition[2]) == 2 or np.argmax(transition[2]) == 3:\n is_contr = True\n elif np.argmax(transition[0]) == 1:\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 2:\n is_contr = True\n if np.argmax(transition[2]) != 1:\n is_contr = True\n elif np.argmax(transition[0]) == 2:\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 1:\n is_contr = True\n elif np.argmax(transition[0]) == 3:\n if np.argmax(transition[1]) != 3:\n is_contr = True\n if np.argmax(transition[2]) == 0 or np.argmax(transition[2]) == 2:\n is_contr = True\n\n # check implicatiosn of upper right corner\n if np.argmax(transition[2]) == 0:\n if np.argmax(transition[0]) == 1 or np.argmax(transition[0]) == 3:\n is_contr = True\n elif np.argmax(transition[2]) == 1:\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 2:\n is_contr = True\n elif np.argmax(transition[2]) == 2:\n if np.argmax(transition[0]) != 2:\n is_contr = True\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 1:\n is_contr = True\n elif np.argmax(transition[2]) == 3:\n if np.argmax(transition[1]) != 3:\n is_contr = True\n if np.argmax(transition[0]) == 0 or np.argmax(transition[0]) == 1:\n is_contr = True\n\n return is_contr","def are_connected(self, node1, node2):\n return bool( self.get_edge(node1, node2) )","def valid_chain(chain):\n\n for i in range(len(chain) - 1):\n parent_edge = chain[i]\n child_edge = chain[i + 1]\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\n if not parent_edge[1] == child_edge[0]:\n # if this isn't\n return False\n return True","def __has_multiple_edges(self):\n return \\\n len(\n list(\n [\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n ] # the length of the list which allows duplicates...\n )\n ) != \\\n len(\n set(\n {\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n } # ...should equal the length of the set that does not allow duplicates\n )\n ) # return True if the two data structures are equal in size and False otherwise","def check_adjacency(layer_a, layer_b, topology):\n adjacency = None\n for node in topology.graph.node.keys():\n if layer_a in node:\n # print topology.graph.edge[node].keys()\n for edge in topology.graph.edge[node].keys():\n if layer_b in edge:\n # print topology.graph.edge[node][edge]\n # print \"Node \",layerA,\" and \",layerB,\" share an edge!\"\n adjacency = True\n if adjacency is True:\n return True\n else:\n return False","def hasConflicts(self):\n partners = {}\n for first, second in self:\n #print >>sys.stderr, \"first:\", first, \"second:\", second\n if first is None:\n if second is None:\n continue #no pairing info\n else:\n first, second = second, first #swap order so None is 2nd\n if second is None: #check first isn't paired\n if partners.get(first, None) is not None:\n print >>sys.stderr, \"here1\"\n print >>sys.stderr, \"first:\", first, \"second:\", second\n return True\n else:\n partners[first] = None\n else: #first and second were both non-empty: check partners\n if first in partners:\n if partners[first] != second:\n print >>sys.stderr, \"here2\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[first]\", partners[first]\n print \"partners:\", partners\n return True\n if second in partners:\n if partners[second] != first:\n print >>sys.stderr, \"here3\"\n print >>sys.stderr, \"first:\", first, \"second:\", second, \"partners[second]:\", partners[second]\n return True\n #add current pair to the list of constraints\n partners[first] = second\n partners[second] = first\n #can only get here if there weren't conflicts\n return False","def _degree_has_changed(first, second):\n return len(set(first) ^ set(second)) != 0","def is_equivalence(self) -> bool:","def check_model(self):\n for node in self.nodes():\n cpd = self.get_cpds(node=node)\n\n if cpd is None:\n raise ValueError(\"No CPD associated with {}\".format(node))\n elif isinstance(cpd, (TabularCPD, ContinuousFactor)):\n evidence = cpd.get_evidence()\n parents = self.get_parents(node)\n if set(evidence if evidence else []) != set(parents if parents else []):\n raise ValueError(\n \"CPD associated with {node} doesn't have \"\n \"proper parents associated with it.\".format(node=node)\n )\n if not cpd.is_valid_cpd():\n raise ValueError(\n \"Sum or integral of conditional probabilites for node {node}\"\n \" is not equal to 1.\".format(node=node)\n )\n return True","def are_connected(self, person1, person2):\n\n possible_nodes = Queue()\n seen = set()\n possible_nodes.enqueue(person1)\n seen.add(person1)\n\n while not possible_nodes.is_empty():\n person = possible_nodes.dequeue()\n print(\"checking\", person)\n if person is person2:\n return True\n else:\n for cohabitant in person.adjacent - seen:\n possible_nodes.enqueue(cohabitant)\n seen.add(cohabitant)\n print(\"added to queue:\", cohabitant)\n return False","def _valid_bond_pair(self, set):\n (sbu1, cp1), (sbu2, cp2) = set\n if all([i is None for i in [cp1.special, cp2.special, cp1.constraint, cp2.constraint]]):\n return sbu1.is_metal != sbu2.is_metal\n\n return (cp1.special == cp2.constraint) and (cp2.special == cp1.constraint)","def consistency(node, sequence, orientation, overlap):\n from_id, to_id = node\n from_sequence, to_sequence = sequence\n from_orn, to_orn = orientation\n if from_orn == '-':\n from_sequence = reverse_and_complement(from_sequence)\n if to_orn == '-':\n to_sequence = reverse_and_complement(to_sequence)\n size_overlap = real_overlap(from_sequence, to_sequence)\n if not size_overlap == overlap:\n GRAPH_LOGGER.debug('Edge between node %s and %s have \\\n \tno consistency between CIGAR overlap end \"real\" overlap', from_id, to_id)\n return False\n\n return True","def check_connected(self, update=True):\n # update if needed\n if update:\n\n self.update_neighbors()\n\n # go through each node checking that each degree id greater than 0\n for node in self.nodes:\n\n # only one node needs to be disconnected to fail\n if len(self.nodes[node].neighbors) < 1:\n return False\n\n return True","def conflateable(seg1, seg2, segment_pairs):\n for segment_pair in segment_pairs:\n seg_set = set(segment_pair)\n if seg1 in seg_set and seg2 in seg_set:\n return True\n return False","def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\n logger.debug(f\"checking symmtrical connections for nodes: {node1}, {node2}\")\n tree1 = set(get_next_level(G,[node1]))\n tree2 = set(get_next_level(G,[node2]))\n traversed1.append(node1)\n traversed2.append(node2)\n if tree1==tree2:\n return True\n while(len(list(tree1))== len(list(tree2)) > 0):\n logger.debug(f\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\")\n tree1 = set(tree1) - set(traversed1)\n tree2 = set(tree2) - set(traversed2)\n\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\n return True\n else:\n traversed1+=list(tree1)\n traversed2+=list(tree2)\n tree1=set(get_next_level(G,tree1))\n tree2=set(get_next_level(G,tree2))\n\n logger.debug(f\"Non symmetrical branches for nets: {node1}, {node2}\")\n return False","def consistent(self):\n return all((constraint.consistent() for constraint in self.constraints))","def connected_pair(self, first, second):\n cover = set()\n queue = {first}\n while queue:\n new = queue.pop()\n cover.add(new)\n for adjacent in new.parents() | new.children():\n if adjacent == second:\n return True\n elif not adjacent in cover:\n queue.add(adjacent)\n return False","def permissible(e1, e2):\n return e1[1] == e2[0] and \\\n total_edge_length(e1, e2) < maximum_distance and \\\n total_edge_angle(e1, e2) < maximum_angle_delta","def is_converged(clusters1, clusters2, k, num_of_cords):\r\n for i in range(k):\r\n for j in range(num_of_cords):\r\n if clusters1[i][j] != clusters2[i][j]:\r\n return False\r\n return True","def is_connected(self, node1, node2):\r\n\r\n return node1 in self.graph and node2 in self.graph[node1]","def check(self):\n\n constrains = pm.ls(type='constraint')\n uselessConstrains = []\n\n for const in constrains:\n connections = const.listConnections(scn=True, s=False, d=True)\n if const in connections:\n connections.remove(const)\n\n if len(connections) == 0:\n uselessConstrains.append(const)\n\n if not uselessConstrains:\n self.status = \"OK\"\n else:\n self.status = self.errorMode\n self.errorNodes = uselessConstrains\n for obj in uselessConstrains:\n self.addError(\"%s doesn't have outgoing connections.\" % obj)\n self.errorMessage = \"%s useless constrains\" % (\n len(uselessConstrains))","def is_consistent(self, constraints):\n for constraint in constraints:\n if not constraint.is_satisfied_with(self):\n return False\n return True","def is_complete(self, A, B):\n return all(self.is_edge(v, w) for v in A for w in B)","def _check_consistency(self, item, path, targets):\n for neighbor in self._edges[path[-1]]:\n if neighbor in path:\n continue\n elif self._nodes[neighbor][item] in (EMPTY, VISITED):\n continue\n\n remaining = set(targets)\n if neighbor in targets:\n remaining.remove(neighbor)\n if len(remaining) == 0:\n return True\n\n if self._check_consistency(item, path + [neighbor], remaining):\n return True\n\n return False","def perms_are_connected(g, n):\n from sage.graphs.graph import Graph\n G = Graph()\n if g:\n G.add_vertices(g[0].domain())\n for p in g:\n G.add_edges(p.dict().items())\n return G.is_connected()","def cross_closeness(self, node_list1, node_list2, link_attribute=None):\n path_lengths = InteractingNetworks.cross_path_lengths(self, node_list1,\n node_list2, link_attribute)\n return self._calculate_general_closeness(path_lengths, internal=False)","def check_pairs(self, all_pr, curr):\n flag = True\n for pair_ox in all_pr:\n if (curr[0] == pair_ox or curr[1] == pair_ox):\n flag = False\n return flag","def is_adjecent(self, cell1, cell2):\r\n if cell1 == cell2:\r\n return True\r\n elif cell1[0] == cell2[0] and (cell1[1] - cell2[1] == 1 or cell1[1] - cell2[1] == -1):\r\n return True\r\n elif cell1[1] == cell2[1] and (cell1[0] - cell2[0] == 1 or cell1[0] - cell2[0] == -1):\r\n return True\r\n else:\r\n return False","def is_connected(self, node1, node2):\r\n\r\n return node1 in self._graph and node2 in self._graph[node1]","def areResonancesProchiral(resonanceA, resonanceB):\n\n if resonanceA.resonanceSet:\n if resonanceB.resonanceSet:\n atomA = resonanceA.resonanceSet.findFirstAtomSet().findFirstAtom()\n atomB = resonanceB.resonanceSet.findFirstAtomSet().findFirstAtom()\n \n residueA = atomA.residue\n residueB = atomB.residue\n \n if residueA is residueB:\n chemAtomSetA = atomA.chemAtom.chemAtomSet\n chemAtomSetB = atomB.chemAtom.chemAtomSet\n\n if chemAtomSetA and (chemAtomSetA is chemAtomSetB):\n return True\n \n return False","def _semantic_feasibility(self, G1_node, G2_node):\n # Make sure the nodes match\n if self.node_match is not None:\n\n nm = self.node_match(G1_node, G2_node)\n if not nm:\n return False\n\n # Make sure the edges match\n if self.edge_match is not None:\n\n # Cached lookups\n G1_adj = self.G1_adj\n G2_adj = self.G2_adj\n core_1 = self.core_1\n edge_match = self.edge_match\n\n for neighbor in G1_adj[G1_node]:\n # G1_node is not in core_1, so we must handle R_self separately\n if neighbor == G1_node:\n if not edge_match(G1_adj[G1_node][G1_node],\n G2_adj[G2_node][G2_node]):\n return False\n elif neighbor in core_1:\n if not edge_match(G1_adj[G1_node][neighbor],\n G2_adj[G2_node][core_1[neighbor]]):\n return False\n # syntactic check has already verified that neighbors are symmetric\n\n return True","def test_not_strongly_connected(self):\n G = DiGraph([(0, 1), (0, 2), (1, 2)])\n assert_false(is_strongly_connected(G))","def _check(self):\n d = self.degree()\n Sd = self.parent()._sym\n\n if prod(self._g, Sd.one()) != Sd.one():\n raise ValueError(\"the product is not identity\")\n\n if self._connected and not perms_are_connected(self._g, d):\n raise ValueError(\"not connected\")","def verified_connection_ft3(self, id1, id2):\n if id2 not in self.users.keys() or id1 not in self.users.keys():\n return False\n\n f1 = self.users[id1]\n f2 = self.users[id2]\n fof1 = self.friends_of_friends(id1, f1)\n fof2 = self.friends_of_friends(id2, f2)\n return len((f1 | fof1) & (f2 | fof2)) != 0","def has_relationship(self, source_node: Node, target_node: Node) -> bool: # pylint: disable=no-self-use\n return source_node.node_id in target_node.in_nodes_ids","def consistent(self, assignment):\n for node1 in assignment:\n for node2 in assignment:\n\n if node1 != node2:\n #returns False if any assignmed words are the same\n if assignment[node1] == assignment[node2]:\n return False\n\n overlap= self.crossword.overlaps[node1,node2]\n if overlap != None:\n #checks if words assigned to node overlaps are the same letter\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\n return False\n\n return True","def check(self,G,N):\n count = 0\n for C in hamiltonian_cycles(G):\n # Count the cycle.\n count += 1\n\n # Check that it's a degree-two undirected subgraph.\n for v in C:\n self.assertEqual(len(C[v]),2)\n for w in C[v]:\n assert v in G and w in G[v] and v in C[w]\n\n # Check that it connects all vertices.\n nreached = 0\n x = arbitrary_item(G)\n a,b = x,x\n while True:\n nreached += 1\n a,b = b,[z for z in C[b] if z != a][0]\n if b == x:\n break\n self.assertEqual(nreached,len(G))\n\n # Did we find enough cycles?\n self.assertEqual(count,N)","def __has_conflicting_node_names(self):\n # check length of sets to determine if overlap exists\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())","def is_acyclic(graph):\n visited = []\n dfs_seq = DFSIterator(graph)\n\n for node in dfs_seq:\n visited.insert(0, node)\n node_neighbors = graph.get_neighbors(node)\n \n for neighbor in node_neighbors:\n if neighbor in visited:\n return False\n\n return True","def _poly_exactly_coincident(a,b):\n n_holes = len(a.holes)\n n_parts = len(a.parts)\n if n_holes != len(b.holes):\n return False\n if n_parts != len(b.parts):\n return False\n b_in_a = [None]*n_holes\n a_in_b = [None]*n_holes\n for i, a_hole in a.holes:\n for j, b_hole in b.holes:\n i_j = coincident(a_hole, b_hole)\n if i_j:\n b_in_a[j] = True\n a_in_b[i] = True\n break\n if not a_in_b[i]:\n return False\n if any(in_b):\n return False\n for b_hole in b.holes:\n in_a = [not coincident(b_hole, a_hole) for a_hole in a.holes]\n if any(in_a):\n return False\n return True","def check_diagonals(self):\n\t\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\n\n\t\tfor diag in diags:\n\t\t\tpts = 0\n\t\t\tfor loc in diag:\n\t\t\t\tif self.board[loc[0]][loc[1]] == self.marker:\n\t\t\t\t\tpts+=1\n\t\t\tif pts == 3:\n\t\t\t\tprint('WE WON')\n\t\t\t\treturn True","def isValidCompatible(cls,root):\n valid = True\n # the order of node types in chains is restricted\n # (this would be easier if the data was in a Corpus-instance)\n allowed = NX.XDiGraph(selfloops=True)\n\n # continue from here!\n allowed.add_edge('Physical','Physical')\n allowed.add_edge('Property','Physical')\n allowed.add_edge('Process','Physical')\n allowed.add_edge('Regulation','Physical')\n\n allowed.add_edge('Property','Property')\n allowed.add_edge('Process','Property')\n allowed.add_edge('Regulation','Property')\n\n allowed.add_edge('Property','Process')\n# allowed.add_edge('Process','Process')\n allowed.add_edge('Regulation','Process')\n\n allowed.add_edge('Property','Regulation')\n# allowed.add_edge('Process','Regulation')\n allowed.add_edge('Regulation','Regulation')\n\n mapping = {}\n for a in root.find(\"ontologies\").findall(\"ontology\"):\n if a.attrib['id']=='interaction':\n for x in a.getiterator(\"ontnode\"):\n if x.attrib.has_key('effect') and x.attrib['effect'].endswith('regulation'):\n t = 'Regulation'\n else:\n t = x.attrib['onttype']\n mapping[x.attrib['id']] = t\n \n for a in root.getiterator(\"relannotation\"):\n t2type = dict( [(x.attrib['id'],x.attrib['type'])\n for x in a.findall(\"reltoken\")] )\n n2t = dict( [(x.attrib['id'],x.attrib['token'])\n for x in a.findall(\"relnode\")] )\n for x in a.findall(\"reledge\"):\n bt = t2type[n2t[x.attrib['bgn']]]\n et = t2type[n2t[x.attrib['end']]]\n bgn = mapping[bt]\n end = mapping[et]\n if not allowed.has_edge(bgn,end):\n printError(cls,inspect.stack()[1][3],\n \"%s -- %s (%s) -> %s (%s) is not a valid edge\"%\n (x.attrib['id'].split('.')[1],bgn,bt,end,et))\n valid = False\n \n return(valid)","def check_regularity(edges):\n for a, b in edges:\n counter_a = 0\n counter_b = 0\n for x, y in edges:\n if a == x or a == y:\n counter_a += 1\n if b == x or b == y:\n counter_b += 1\n assert (counter_a > 0) and (counter_b > 0)\n if (counter_a == 1) or (counter_b == 1):\n raise Exception(\"Boundary is not closed.\")\n if (counter_a > 2) or (counter_b > 2):\n raise Exception(\"More than two edges share a node.\")","def nodes_are_interconnected(graph, nodes):\n \n nid_list = []\n for node in nodes:\n if hasattr(node, 'nid'):\n nid_list.append(node.nid)\n elif node in graph.nodes:\n nid_list.append(node)\n else:\n raise 'Node not in graph {0}'.format(node)\n\n nid_list = set(nid_list)\n\n collection = []\n for nid in nid_list:\n query = set(graph.adjacency[nid] + [nid])\n collection.append(query.intersection(nid_list) == nid_list)\n \n return all(collection)","def check_nodes(self) -> bool:\n # check the input-output consistency\n for op_name in self.__ops:\n op = cast(Operator, self.__ops[op_name])\n inputs: Dict[str, Operator] = op.input_ops\n for i in inputs.values():\n if op not in i.output_op_list:\n return False\n\n return True","def hasNoDoubleVertices(self):\n assert all(self.vertices.count(v) == 1 for v in self.vertices)\n return (all(all(v1 == v2 or v1.dist(v2) > COMPARISON_EPSILON for v2 in self.vertices)\n for v1 in self.vertices) and\n all(self.vertices.count(v) == 1 for v in self.vertices))","def haveNoSameEdges(seg1,seg2,segmentsMeta):\n seg1Edges = segmentsMeta['edges'][seg1]\n seg2Edges = segmentsMeta['edges'][seg2]\n return not any(a==b for a in seg1Edges for b in seg2Edges)","def connected(self, x, y):\n\n return self.__find_root(x) == self.__find_root(y)","def test_is_strongly_connected(self):\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\n assert_true(is_strongly_connected(G))","def is_connected(object_one, object_two):\n\n for vert_one in object_one.Vertexes:\n for vert_two in object_two.Vertexes:\n if (vert_one.X == vert_two.X) and (vert_one.y == vert_two.y):\n return True\n\n return False","def consistent(h, phi):\n for n in h: # for each node in h\n if phi(n) in h and phi(n) not in h:\n return False\n return True","def AreConnected(self, node1_idx, node2_idx):\n for n in self.nodes:\n if n.index == node1_idx:\n a = n\n elif n.index == node2_idx:\n b = n\n\n return ((b.index in a.neighbours) and (a.index in b.neighbours))","def connected(self, avoid=set()):\n if len(self) <= 1:\n return True\n cover = set()\n queue = {(self.nodes() - avoid).pop()} # Take some element not being avoided\n while queue:\n new = queue.pop()\n cover.add(new)\n for adjacent in new.parents() | new.children():\n if not (adjacent in cover or adjacent in avoid):\n queue.add(adjacent)\n if len(cover) == len(self) - len(avoid):\n return True\n else:\n return False","def check(self, expected, debug=True):\r\n for v1, v2, go in expected:\r\n for gj, oj in go:\r\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\r\n assert r1 == oj\r\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\r\n assert r2 == oj","def test_consistent_ids(self) -> None:\n bnode = BNode()\n g0_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Golan Trevize\")),\n (bnode, RDF.type, FOAF.Person),\n }\n bnode = BNode()\n g1_ts: _TripleSet = {\n (bnode, FOAF.name, Literal(\"Janov Pelorat\")),\n (bnode, RDF.type, FOAF.Person),\n }\n\n g0 = Graph()\n g0 += g0_ts\n cg0 = to_canonical_graph(g0)\n cg0_ts = GraphHelper.triple_set(cg0)\n\n g1 = Graph()\n g1 += g1_ts\n cg1 = to_canonical_graph(g1)\n cg1_ts = GraphHelper.triple_set(cg1)\n\n assert cg0_ts.issubset(\n cg1_ts\n ), \"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\"","def isIsosceles(self):\n\t\treturn self.a == self.b or self.a == self.c or self.b == self.c","def validate(self, fgraph):\r\n\r\n if self.destroyers:\r\n ords = self.orderings(fgraph)\r\n\r\n if _contains_cycle(fgraph, ords):\r\n raise InconsistencyError(\"Dependency graph contains cycles\")\r\n else:\r\n #James's Conjecture:\r\n #If there are no destructive ops, then there can be no cycles.\r\n pass\r\n return True","def mayConnect(self, from_node, to_node):\n if from_node in self.graph and to_node in self.graph[from_node]:\n # Connection already exists\n return False\n ret = True\n self.connect(from_node, to_node)\n visited = [False] * self.num_vertices\n for i in range(self.num_vertices):\n if not visited[i]:\n if self.hasCycle(i, visited, -1):\n ret = False\n break\n self.disconnect(from_node, to_node)\n return ret","def feature_two(ds, tup):\n # try:\n # if (nx.shortest_path_length(G, frm, to) == 2):\n # o2.write(\"trusted\\n\")\n # else:\n # o2.write(\"unverified\\n\")\n # except:\n # o2.write(\"unverified\\n\")\n\n A_child = ds[tup[0]]\n C_child = ds[tup[1]]\n return ((len(A_child.intersection(C_child)) > 0) | (tup[0] in ds[tup[1]]))","def graph_is_connected(node_count, edges):\n\n disjoint_set = disjoint.DisjointSet(node_count + 1)\n\n for a, b in edges:\n disjoint_set.union(a, b)\n\n # Check if all nodes are part of the same set\n\n root = disjoint_set.root(1)\n\n for i in range(2, node_count + 1):\n if disjoint_set.root(i) != root:\n return False\n\n return True","def check_all_constraints(csp) :\n\n for constraint in csp.get_all_constraints():\n assigned1 = csp.get_assigned_value(constraint.var1)\n assigned2 = csp.get_assigned_value(constraint.var2)\n check = constraint.check(assigned1,assigned2)\n if check==False and assigned1!=None and assigned2!=None:\n return False \n return True","def validate(self, fgraph):\r\n\r\n if self.destroyers:\r\n ords = self.orderings(fgraph)\r\n\r\n if _contains_cycle(fgraph, ords):\r\n raise InconsistencyError(\"Dependency graph contains cycles\")\r\n else:\r\n #James's Conjecture:\r\n #If there are no destructive ops, then there can be no cycles.\r\n pass\r\n return True","def is_valid_adjacency_matrix(connections, num_intermediate, num_input, num_output):\n\n num_emitting = num_intermediate + num_input\n num_receiving = num_intermediate + num_output\n\n if connections.size(0) < num_receiving:\n return False\n if connections.size(1) < num_emitting:\n return False\n\n embedded_intermediate_size = connections.size(0) - num_output\n #check that dimensions of the connectivity tensor are consistent with single fixed intermediate size\n if embedded_intermediate_size < 0 or embedded_intermediate_size != connections.size(1) - num_input:\n return False\n\n # check left-justified\n if connections[num_receiving:, :].sum().item() > 0:\n return False\n if connections[:, num_emitting:].sum().item() > 0:\n return False\n # check that vertices only receive input from ancestors\n for i in range(num_receiving):\n if connections[i, i+ num_input:].sum().item() > 0:\n return False\n return True","def valid_colset_pair((cset1, cset2), pairedcols):\n c1a, cia, cna = cset1\n c1b, cib, cnb = cset2\n seta = set([c1a, cna]) | cia\n setb = set([c1b, cnb]) | cib\n if not seta.isdisjoint(setb):\n for a, b in pairedcols:\n if cna == a and c1b == b:\n return False\n if cnb == a and c1a == b:\n return False\n if c1a in setb and cna in setb and not seta <= setb:\n return False\n if c1b in seta and cnb in seta and not setb <= seta:\n return False\n if cna not in set([cnb]) | cib and cnb not in set([cna]) | cia:\n return False\n if c1a not in set([c1b]) | cib and c1b not in set([c1a]) | cia:\n return False\n return True","def test_reachable_pair(self):\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\n assert_true(is_reachable(G, 0, 2))","def is_weakly_connected(G):\n if len(G) == 0:\n raise nx.NetworkXPointlessConcept(\n \"\"\"Connectivity is undefined for the null graph.\"\"\")\n\n return len(list(weakly_connected_components(G))[0]) == len(G)","def contains_edge(self, node, other_node):\n return \\\n {node.get_name(), other_node.get_name()} in \\\n list([\n {edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()}\n for edge in self.get_edges()\n ]) # return true if there exists an edge between the input nodes and false otherwise","def exact_fact_check(self, triple, transitive=False):\n exists = self.knowledge_graph.check_triple_object_existence(triple, transitive)\n if exists is True:\n return 'exists', []\n conflicts = self.knowledge_graph.get_triples(triple.subject, triple.relation, transitive)\n if conflicts is not None:\n return 'conflicts', conflicts\n # The following checks triples with the same subject and object, but different relation. Are those conflict?\n # if conflicts is None:\n # conflicts = []\n # for obj in triple.objects:\n # relations = self.knowledge_graph.get_relation_triples(triple.subject, obj)\n # if relations is not None:\n # conflicts += relations\n # if len(conflicts) > 0:\n # return 'conflicts', conflicts\n return 'none', []","def is_crossed(self):\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\n self.cluster[0])\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\n self.cluster[-1])\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()","def check_undirected(graph):\n for node in graph:\n for neighbor in graph[node]:\n if node not in graph[neighbor]:\n return False\n return True","def mismatches(self, sequence, pairs=None):\n mismatches = 0\n if pairs is None:\n try:\n pairs = sequence.Alphabet.Pairs\n except AttributeError:\n pairs = sequence.Pairs\n \n for up, down in self.directed():\n curr = (sequence[up], sequence[down])\n if curr not in pairs:\n mismatches += 1\n return mismatches","def is_contradiction(formula: Formula) -> bool:\n # Task 2.5b\n return not is_satisfiable(formula)","def is_contradiction(formula: Formula) -> bool:\r\n # Task 2.5b\r\n return not is_satisfiable(formula)","def check_perm(tri1,tri2):\n for t1 in tri1:\n for t2 in tri2:\n if t1 == t2:\n return False\n return True","def verbose_are_connected_recursive(self, person1, person2, seen=None):\n\n if not seen:\n seen = set()\n\n if person1 is person2:\n print(\"\\nreturning True - {} is {}\".format(person1.name, person2.name))\n return True\n\n seen.add(person1) # Keep track that we've visited here\n print(\"adding\", person1)\n\n for person in person1.adjacent:\n\n if person not in seen:\n\n print(\"calling method on {}'s cohabitant {} with {}\".format(person1.name, person.name, person2.name))\n if self.verbose_are_connected_recursive(person, person2, seen):\n print(\"\\nreturning True from checking {}\".format(person.name))\n return True\n\n print(\"returning False from checking {}\".format(person1.name))\n return False","def test_case7(self):\n\n graph3 = self.graph1.merge(self.graph2)\n\n expected = {'supervisor1':['student1','student2','student4'],'supervisor2':['student4','student1','student3'],'supervisor3':['student3','student2']}\n\n result = True\n\n for sup in expected:\n for stu in expected[sup]:\n if not graph3.isEdge(sup,stu):\n result = False\n break\n\n self.assertTrue(result)","def validate_conn(self, solution):\r\n\r\n active_nodes = [idx for idx, value in enumerate(solution) # remove not included nodes in solution\r\n if value != 0 and idx not in self.dead_nodes and self.network.get_node(idx).energy >= cf.COMMUNICATION_ENERGY]\r\n active_nodes.append(-1) # add a sink node \r\n visited = self.DFS(self.network_graph, active_nodes[0], active_nodes)\r\n if len(visited) == len(active_nodes):\r\n return True\r\n else:\r\n return False","def test_same_node_is_reachable(self):\n # G is an arbitrary tournament on ten nodes.\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\n assert_true(all(is_reachable(G, v, v) for v in G))","def check_symmetric(adj : np.ndarray, tol : float = 1e-8) -> bool:\n return np.all(np.abs(adj-adj.T) < tol)","def check_relations(self, relations):\n if self.debug:\n print(\"Checking relations\")\n result = False\n work_relations = []\n\n # Eliminate unnecessary(duplicated) clauses\n if relations[\"is_derived_from\"]:\n relations[\"has_derived_form\"] = True\n relations[\"is_derived_from\"] = False\n if relations[\"etymology\"]:\n relations[\"etymological_origin_of\"] = True\n relations[\"etymology\"] = False\n\n for relation in relations:\n if relations[relation]:\n result = True\n work_relations.append(relation)\n return result, work_relations","def compare(self, node) -> bool:\n\t\t# No conflicts, Return True\n\t\treturn True","def is_good_cyc(path, G, bamfile):\n\n sing_nodes = set()\n for node in path:\n if node[-1] == \"'\": node = node[:-1]\n sing_nodes.add(node)\n if len(sing_nodes)==0: return True\n\n non_path_dominated_nodes = 0\n\n for nd in sing_nodes:\n mate_tigs = get_contigs_of_mates(nd, bamfile, G)\n # NOTE: ^ this only gets mates that are reachable from nd in G\n logger.info(\"\\tNode: %s\" % nd)\n logger.info(\"\\t\\tMates: %s\" % \", \".join(mate_tigs))\n\n # need to check against F and R versions of path nodes\n path_rc = [rc_node(x) for x in path]\n num_mates_in_path = sum([1 for x in mate_tigs if (x in path or x in path_rc)])\n num_mates_not_in_path = len(mate_tigs)-num_mates_in_path\n if num_mates_in_path < num_mates_not_in_path:\n ########### if len(mate_tigs)>1 and num_mates_in_path < num_mates_not_in_path:\n non_path_dominated_nodes += 1\n if float(non_path_dominated_nodes)/float(len(sing_nodes)) > PARAMS.GOOD_CYC_DOMINATED_THRESH:\n logger.info(\"Too many nodes with majority of mates not on path\")\n return False\n else: return True","def pair_is_consistent(graph, u, v):\n relations = get_all_relations(graph, u, v)\n\n if 1 != len(relations):\n return False\n\n return list(relations)[0]","def has_cycle(graph):\n ds = DisjointSet()\n\n # creates a set of all graph nodes\n node_set = set()\n for edge in graph:\n node_set.add(edge.node1)\n node_set.add(edge.node2)\n\n for item in node_set:\n ds.make_set(item)\n\n for edge in graph:\n same_set = ds.union(edge.node1, edge.node2)\n if same_set:\n return True\n\n return False","def can_relax_constraints(self):\n if len(self.mand_classroom_constraints) == 0:\n if len(self.high_classroom_constraints) > 0:\n return True\n else:\n for cc in self.low_classroom_constraints:\n if cc.can_relax_constraints():\n return True\n\n if len(self.mand_timeblock_ids) == 0:\n if len(self.high_timeblock_ids) > 0:\n return True\n\n return False","def cross_transitivity_sparse(self, node_list1, node_list2):\n cross_degree = self.cross_degree(node_list1, node_list2)\n\n # Get sparse adjacency matrix\n A = self.sp_A[node_list1+node_list2, :][:, node_list1+node_list2]\n # Get subnetwork sizes\n N1, N2 = len(node_list1), len(node_list2)\n # Initialize\n cross_transitivity = 0.0\n # Set counter\n counter_triangles = 0.0\n counter_triples = 0.0\n # Calculate cross transitivity from subnetwork 1 to subnetwork 2\n # Loop over nodes in subnetwork 1\n for i in range(N1):\n node1 = i\n if cross_degree[i] > 1:\n # Loop over unique pairs of nodes in subnetwork 2\n for j in range(N1, N1+N2):\n node2 = j\n for k in range(N1, j):\n node3 = k\n if A[node1, node2] == 1 and A[node1, node3] == 1:\n counter_triples += 1\n if A[node2, node3] == 1:\n counter_triangles += 1\n\n if counter_triples:\n cross_transitivity = counter_triangles / counter_triples\n return cross_transitivity","def identical_cds(sc1,sc2):\n # Input 2 identical segment chains, return True if cds the same\n if sc1.covers(sc2) and sc2.covers(sc1):\n return True\n else:\n return False","def check_cons(term, cons):\n res = True\n for constr in cons:\n if constr.issubset(term):\n res = False\n break\n return res","def enforce_node_consistency(self):\n # Loop over each variable (space for word) in the crossword\n # Use copy to prevent domains from being modified while looping\n for var in self.domains.copy():\n # Get all unary constraints for this variable\n for value in self.domains[var].copy():\n # Check if the value is consistent with all unary constraints\n if len(value) != var.length:\n # If not, remove the value from the domain\n self.domains[var].remove(value)\n # No return value is necessary","def is_connected_same_node(graph, node_u, node_v):\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\n if out_neighbor_u == out_neighbor_v:\n return True\n return False","def victory_checker() -> bool:\r\n conflict_check()\r\n for x in range(shape):\r\n for y in range(shape):\r\n if conflict_space[x, y] != 0:\r\n return False\r\n if separation_crawler(False):\r\n return False\r\n return True","def check_all_constraints(csp) :\n constraints=csp.get_all_constraints()\n for constraint in constraints:\n var1 = constraint.var1\n var2 = constraint.var2\n val1=csp.get_assigned_value(var1)\n val2=csp.get_assigned_value(var2)\n if val1!=None and val2!=None:\n if not constraint.check(val1,val2):\n return False\n return True","def all_covered(matches, molecule) -> bool:\n # check atoms\n for i in range(molecule.n_atoms):\n assert (i, ) in matches\n # check bonds\n for bond in molecule.bonds:\n bond = (bond.atom1_index, bond.atom2_index)\n assert bond in matches or tuple(reversed(bond)) in matches\n # check angles\n for angle in molecule.angles:\n angle = tuple([atom.molecule_atom_index for atom in angle])\n assert angle in matches or tuple(reversed(angle)) in matches\n # check torsions\n for torsion in molecule.propers:\n dihedral = tuple([atom.molecule_atom_index for atom in torsion])\n assert dihedral in matches or tuple(reversed(dihedral)) in matches\n\n return True","def is_exceptional(self):\n G = self.poset().hasse_diagram()\n for x in G:\n nx = list(G.neighbors_out(x))\n nx.append(x)\n if min(nx) < x and max(nx) > x:\n return False\n return True","def dist(self, one, two):\n return sum((one[0] != two[0], one[1] != two[1]))","def nsi_cross_closeness_centrality(self, node_list1, node_list2):\n shortest_paths = self.path_lengths()\n node_weights = self.node_weights\n\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\n\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\n W = sum(node_weights[node_list2])\n return W / np.dot(nsi_cross_paths, node_weights[node_list2])","def IsCyclic(self):\n\n visited = [False for i in range(self.NodesCount())]\n \n for idx in range(1, self.NodesCount()+1): \n if not visited[idx-1]: \n if self.IsCyclicRec(idx, visited, -1): \n return True\n return False","def valid_colset_comb(prod, pairedcols):\n for c1, ci, cn in prod:\n cols = set([c1, cn]) | ci\n for a, b in pairedcols:\n if (a in ci and b not in ci and b != cn) or (b in ci and a not in ci and a != c1):\n return False\n if (a == c1 and b not in ci) or (a == cn and b in cols):\n return False\n if (b == c1 and a in cols) or (b == cn and a not in ci):\n return False\n return all(valid_colset_pair(x, pairedcols) for x in combinations(prod, 2))"],"string":"[\n \"def relation_set_has_contradictions(relations):\\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\\n return 1 < sum([has_cnc, has_decreases, has_increases])\",\n \"def get_contradictory_pairs(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_has_contradiction(graph, u, v):\\n yield u, v\",\n \"def is_contradiction_(transition):\\n is_contr = False\\n\\n # check implications of lower left corner\\n if np.argmax(transition[0]) == 0:\\n if np.argmax(transition[2]) == 2 or np.argmax(transition[2]) == 3:\\n is_contr = True\\n elif np.argmax(transition[0]) == 1:\\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 2:\\n is_contr = True\\n if np.argmax(transition[2]) != 1:\\n is_contr = True\\n elif np.argmax(transition[0]) == 2:\\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 1:\\n is_contr = True\\n elif np.argmax(transition[0]) == 3:\\n if np.argmax(transition[1]) != 3:\\n is_contr = True\\n if np.argmax(transition[2]) == 0 or np.argmax(transition[2]) == 2:\\n is_contr = True\\n\\n # check implicatiosn of upper right corner\\n if np.argmax(transition[2]) == 0:\\n if np.argmax(transition[0]) == 1 or np.argmax(transition[0]) == 3:\\n is_contr = True\\n elif np.argmax(transition[2]) == 1:\\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 2:\\n is_contr = True\\n elif np.argmax(transition[2]) == 2:\\n if np.argmax(transition[0]) != 2:\\n is_contr = True\\n if np.argmax(transition[1]) == 0 or np.argmax(transition[1]) == 1:\\n is_contr = True\\n elif np.argmax(transition[2]) == 3:\\n if np.argmax(transition[1]) != 3:\\n is_contr = True\\n if np.argmax(transition[0]) == 0 or np.argmax(transition[0]) == 1:\\n is_contr = True\\n\\n return is_contr\",\n \"def are_connected(self, node1, node2):\\n return bool( self.get_edge(node1, node2) )\",\n \"def valid_chain(chain):\\n\\n for i in range(len(chain) - 1):\\n parent_edge = chain[i]\\n child_edge = chain[i + 1]\\n # verify that the child of the parent edge (second node) matches the parent of the child edge (first node)\\n if not parent_edge[1] == child_edge[0]:\\n # if this isn't\\n return False\\n return True\",\n \"def __has_multiple_edges(self):\\n return \\\\\\n len(\\n list(\\n [\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n ] # the length of the list which allows duplicates...\\n )\\n ) != \\\\\\n len(\\n set(\\n {\\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\\n for edge in self.get_edges()\\n } # ...should equal the length of the set that does not allow duplicates\\n )\\n ) # return True if the two data structures are equal in size and False otherwise\",\n \"def check_adjacency(layer_a, layer_b, topology):\\n adjacency = None\\n for node in topology.graph.node.keys():\\n if layer_a in node:\\n # print topology.graph.edge[node].keys()\\n for edge in topology.graph.edge[node].keys():\\n if layer_b in edge:\\n # print topology.graph.edge[node][edge]\\n # print \\\"Node \\\",layerA,\\\" and \\\",layerB,\\\" share an edge!\\\"\\n adjacency = True\\n if adjacency is True:\\n return True\\n else:\\n return False\",\n \"def hasConflicts(self):\\n partners = {}\\n for first, second in self:\\n #print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n if first is None:\\n if second is None:\\n continue #no pairing info\\n else:\\n first, second = second, first #swap order so None is 2nd\\n if second is None: #check first isn't paired\\n if partners.get(first, None) is not None:\\n print >>sys.stderr, \\\"here1\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second\\n return True\\n else:\\n partners[first] = None\\n else: #first and second were both non-empty: check partners\\n if first in partners:\\n if partners[first] != second:\\n print >>sys.stderr, \\\"here2\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[first]\\\", partners[first]\\n print \\\"partners:\\\", partners\\n return True\\n if second in partners:\\n if partners[second] != first:\\n print >>sys.stderr, \\\"here3\\\"\\n print >>sys.stderr, \\\"first:\\\", first, \\\"second:\\\", second, \\\"partners[second]:\\\", partners[second]\\n return True\\n #add current pair to the list of constraints\\n partners[first] = second\\n partners[second] = first\\n #can only get here if there weren't conflicts\\n return False\",\n \"def _degree_has_changed(first, second):\\n return len(set(first) ^ set(second)) != 0\",\n \"def is_equivalence(self) -> bool:\",\n \"def check_model(self):\\n for node in self.nodes():\\n cpd = self.get_cpds(node=node)\\n\\n if cpd is None:\\n raise ValueError(\\\"No CPD associated with {}\\\".format(node))\\n elif isinstance(cpd, (TabularCPD, ContinuousFactor)):\\n evidence = cpd.get_evidence()\\n parents = self.get_parents(node)\\n if set(evidence if evidence else []) != set(parents if parents else []):\\n raise ValueError(\\n \\\"CPD associated with {node} doesn't have \\\"\\n \\\"proper parents associated with it.\\\".format(node=node)\\n )\\n if not cpd.is_valid_cpd():\\n raise ValueError(\\n \\\"Sum or integral of conditional probabilites for node {node}\\\"\\n \\\" is not equal to 1.\\\".format(node=node)\\n )\\n return True\",\n \"def are_connected(self, person1, person2):\\n\\n possible_nodes = Queue()\\n seen = set()\\n possible_nodes.enqueue(person1)\\n seen.add(person1)\\n\\n while not possible_nodes.is_empty():\\n person = possible_nodes.dequeue()\\n print(\\\"checking\\\", person)\\n if person is person2:\\n return True\\n else:\\n for cohabitant in person.adjacent - seen:\\n possible_nodes.enqueue(cohabitant)\\n seen.add(cohabitant)\\n print(\\\"added to queue:\\\", cohabitant)\\n return False\",\n \"def _valid_bond_pair(self, set):\\n (sbu1, cp1), (sbu2, cp2) = set\\n if all([i is None for i in [cp1.special, cp2.special, cp1.constraint, cp2.constraint]]):\\n return sbu1.is_metal != sbu2.is_metal\\n\\n return (cp1.special == cp2.constraint) and (cp2.special == cp1.constraint)\",\n \"def consistency(node, sequence, orientation, overlap):\\n from_id, to_id = node\\n from_sequence, to_sequence = sequence\\n from_orn, to_orn = orientation\\n if from_orn == '-':\\n from_sequence = reverse_and_complement(from_sequence)\\n if to_orn == '-':\\n to_sequence = reverse_and_complement(to_sequence)\\n size_overlap = real_overlap(from_sequence, to_sequence)\\n if not size_overlap == overlap:\\n GRAPH_LOGGER.debug('Edge between node %s and %s have \\\\\\n \\tno consistency between CIGAR overlap end \\\"real\\\" overlap', from_id, to_id)\\n return False\\n\\n return True\",\n \"def check_connected(self, update=True):\\n # update if needed\\n if update:\\n\\n self.update_neighbors()\\n\\n # go through each node checking that each degree id greater than 0\\n for node in self.nodes:\\n\\n # only one node needs to be disconnected to fail\\n if len(self.nodes[node].neighbors) < 1:\\n return False\\n\\n return True\",\n \"def conflateable(seg1, seg2, segment_pairs):\\n for segment_pair in segment_pairs:\\n seg_set = set(segment_pair)\\n if seg1 in seg_set and seg2 in seg_set:\\n return True\\n return False\",\n \"def compare_balanced_tree(G, node1:str, node2:str, traversed1:list, traversed2:list):\\n logger.debug(f\\\"checking symmtrical connections for nodes: {node1}, {node2}\\\")\\n tree1 = set(get_next_level(G,[node1]))\\n tree2 = set(get_next_level(G,[node2]))\\n traversed1.append(node1)\\n traversed2.append(node2)\\n if tree1==tree2:\\n return True\\n while(len(list(tree1))== len(list(tree2)) > 0):\\n logger.debug(f\\\"tree1 {tree1} tree2 {tree2} traversed1 {traversed1} traversed2 {traversed2}\\\")\\n tree1 = set(tree1) - set(traversed1)\\n tree2 = set(tree2) - set(traversed2)\\n\\n if tree1.intersection(tree2) or len(list(tree1))== len(list(tree2))==0:\\n return True\\n else:\\n traversed1+=list(tree1)\\n traversed2+=list(tree2)\\n tree1=set(get_next_level(G,tree1))\\n tree2=set(get_next_level(G,tree2))\\n\\n logger.debug(f\\\"Non symmetrical branches for nets: {node1}, {node2}\\\")\\n return False\",\n \"def consistent(self):\\n return all((constraint.consistent() for constraint in self.constraints))\",\n \"def connected_pair(self, first, second):\\n cover = set()\\n queue = {first}\\n while queue:\\n new = queue.pop()\\n cover.add(new)\\n for adjacent in new.parents() | new.children():\\n if adjacent == second:\\n return True\\n elif not adjacent in cover:\\n queue.add(adjacent)\\n return False\",\n \"def permissible(e1, e2):\\n return e1[1] == e2[0] and \\\\\\n total_edge_length(e1, e2) < maximum_distance and \\\\\\n total_edge_angle(e1, e2) < maximum_angle_delta\",\n \"def is_converged(clusters1, clusters2, k, num_of_cords):\\r\\n for i in range(k):\\r\\n for j in range(num_of_cords):\\r\\n if clusters1[i][j] != clusters2[i][j]:\\r\\n return False\\r\\n return True\",\n \"def is_connected(self, node1, node2):\\r\\n\\r\\n return node1 in self.graph and node2 in self.graph[node1]\",\n \"def check(self):\\n\\n constrains = pm.ls(type='constraint')\\n uselessConstrains = []\\n\\n for const in constrains:\\n connections = const.listConnections(scn=True, s=False, d=True)\\n if const in connections:\\n connections.remove(const)\\n\\n if len(connections) == 0:\\n uselessConstrains.append(const)\\n\\n if not uselessConstrains:\\n self.status = \\\"OK\\\"\\n else:\\n self.status = self.errorMode\\n self.errorNodes = uselessConstrains\\n for obj in uselessConstrains:\\n self.addError(\\\"%s doesn't have outgoing connections.\\\" % obj)\\n self.errorMessage = \\\"%s useless constrains\\\" % (\\n len(uselessConstrains))\",\n \"def is_consistent(self, constraints):\\n for constraint in constraints:\\n if not constraint.is_satisfied_with(self):\\n return False\\n return True\",\n \"def is_complete(self, A, B):\\n return all(self.is_edge(v, w) for v in A for w in B)\",\n \"def _check_consistency(self, item, path, targets):\\n for neighbor in self._edges[path[-1]]:\\n if neighbor in path:\\n continue\\n elif self._nodes[neighbor][item] in (EMPTY, VISITED):\\n continue\\n\\n remaining = set(targets)\\n if neighbor in targets:\\n remaining.remove(neighbor)\\n if len(remaining) == 0:\\n return True\\n\\n if self._check_consistency(item, path + [neighbor], remaining):\\n return True\\n\\n return False\",\n \"def perms_are_connected(g, n):\\n from sage.graphs.graph import Graph\\n G = Graph()\\n if g:\\n G.add_vertices(g[0].domain())\\n for p in g:\\n G.add_edges(p.dict().items())\\n return G.is_connected()\",\n \"def cross_closeness(self, node_list1, node_list2, link_attribute=None):\\n path_lengths = InteractingNetworks.cross_path_lengths(self, node_list1,\\n node_list2, link_attribute)\\n return self._calculate_general_closeness(path_lengths, internal=False)\",\n \"def check_pairs(self, all_pr, curr):\\n flag = True\\n for pair_ox in all_pr:\\n if (curr[0] == pair_ox or curr[1] == pair_ox):\\n flag = False\\n return flag\",\n \"def is_adjecent(self, cell1, cell2):\\r\\n if cell1 == cell2:\\r\\n return True\\r\\n elif cell1[0] == cell2[0] and (cell1[1] - cell2[1] == 1 or cell1[1] - cell2[1] == -1):\\r\\n return True\\r\\n elif cell1[1] == cell2[1] and (cell1[0] - cell2[0] == 1 or cell1[0] - cell2[0] == -1):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def is_connected(self, node1, node2):\\r\\n\\r\\n return node1 in self._graph and node2 in self._graph[node1]\",\n \"def areResonancesProchiral(resonanceA, resonanceB):\\n\\n if resonanceA.resonanceSet:\\n if resonanceB.resonanceSet:\\n atomA = resonanceA.resonanceSet.findFirstAtomSet().findFirstAtom()\\n atomB = resonanceB.resonanceSet.findFirstAtomSet().findFirstAtom()\\n \\n residueA = atomA.residue\\n residueB = atomB.residue\\n \\n if residueA is residueB:\\n chemAtomSetA = atomA.chemAtom.chemAtomSet\\n chemAtomSetB = atomB.chemAtom.chemAtomSet\\n\\n if chemAtomSetA and (chemAtomSetA is chemAtomSetB):\\n return True\\n \\n return False\",\n \"def _semantic_feasibility(self, G1_node, G2_node):\\n # Make sure the nodes match\\n if self.node_match is not None:\\n\\n nm = self.node_match(G1_node, G2_node)\\n if not nm:\\n return False\\n\\n # Make sure the edges match\\n if self.edge_match is not None:\\n\\n # Cached lookups\\n G1_adj = self.G1_adj\\n G2_adj = self.G2_adj\\n core_1 = self.core_1\\n edge_match = self.edge_match\\n\\n for neighbor in G1_adj[G1_node]:\\n # G1_node is not in core_1, so we must handle R_self separately\\n if neighbor == G1_node:\\n if not edge_match(G1_adj[G1_node][G1_node],\\n G2_adj[G2_node][G2_node]):\\n return False\\n elif neighbor in core_1:\\n if not edge_match(G1_adj[G1_node][neighbor],\\n G2_adj[G2_node][core_1[neighbor]]):\\n return False\\n # syntactic check has already verified that neighbors are symmetric\\n\\n return True\",\n \"def test_not_strongly_connected(self):\\n G = DiGraph([(0, 1), (0, 2), (1, 2)])\\n assert_false(is_strongly_connected(G))\",\n \"def _check(self):\\n d = self.degree()\\n Sd = self.parent()._sym\\n\\n if prod(self._g, Sd.one()) != Sd.one():\\n raise ValueError(\\\"the product is not identity\\\")\\n\\n if self._connected and not perms_are_connected(self._g, d):\\n raise ValueError(\\\"not connected\\\")\",\n \"def verified_connection_ft3(self, id1, id2):\\n if id2 not in self.users.keys() or id1 not in self.users.keys():\\n return False\\n\\n f1 = self.users[id1]\\n f2 = self.users[id2]\\n fof1 = self.friends_of_friends(id1, f1)\\n fof2 = self.friends_of_friends(id2, f2)\\n return len((f1 | fof1) & (f2 | fof2)) != 0\",\n \"def has_relationship(self, source_node: Node, target_node: Node) -> bool: # pylint: disable=no-self-use\\n return source_node.node_id in target_node.in_nodes_ids\",\n \"def consistent(self, assignment):\\n for node1 in assignment:\\n for node2 in assignment:\\n\\n if node1 != node2:\\n #returns False if any assignmed words are the same\\n if assignment[node1] == assignment[node2]:\\n return False\\n\\n overlap= self.crossword.overlaps[node1,node2]\\n if overlap != None:\\n #checks if words assigned to node overlaps are the same letter\\n if assignment[node1][overlap[0]] != assignment[node2][overlap[1]]:\\n return False\\n\\n return True\",\n \"def check(self,G,N):\\n count = 0\\n for C in hamiltonian_cycles(G):\\n # Count the cycle.\\n count += 1\\n\\n # Check that it's a degree-two undirected subgraph.\\n for v in C:\\n self.assertEqual(len(C[v]),2)\\n for w in C[v]:\\n assert v in G and w in G[v] and v in C[w]\\n\\n # Check that it connects all vertices.\\n nreached = 0\\n x = arbitrary_item(G)\\n a,b = x,x\\n while True:\\n nreached += 1\\n a,b = b,[z for z in C[b] if z != a][0]\\n if b == x:\\n break\\n self.assertEqual(nreached,len(G))\\n\\n # Did we find enough cycles?\\n self.assertEqual(count,N)\",\n \"def __has_conflicting_node_names(self):\\n # check length of sets to determine if overlap exists\\n return len({node.get_name() for node in self.get_nodeset()}) != len(self.get_nodeset())\",\n \"def is_acyclic(graph):\\n visited = []\\n dfs_seq = DFSIterator(graph)\\n\\n for node in dfs_seq:\\n visited.insert(0, node)\\n node_neighbors = graph.get_neighbors(node)\\n \\n for neighbor in node_neighbors:\\n if neighbor in visited:\\n return False\\n\\n return True\",\n \"def _poly_exactly_coincident(a,b):\\n n_holes = len(a.holes)\\n n_parts = len(a.parts)\\n if n_holes != len(b.holes):\\n return False\\n if n_parts != len(b.parts):\\n return False\\n b_in_a = [None]*n_holes\\n a_in_b = [None]*n_holes\\n for i, a_hole in a.holes:\\n for j, b_hole in b.holes:\\n i_j = coincident(a_hole, b_hole)\\n if i_j:\\n b_in_a[j] = True\\n a_in_b[i] = True\\n break\\n if not a_in_b[i]:\\n return False\\n if any(in_b):\\n return False\\n for b_hole in b.holes:\\n in_a = [not coincident(b_hole, a_hole) for a_hole in a.holes]\\n if any(in_a):\\n return False\\n return True\",\n \"def check_diagonals(self):\\n\\t\\tdiags = [[(0,0), (1,1), (2,2)], [(0,2), (1,1), (2,0)]]\\n\\n\\t\\tfor diag in diags:\\n\\t\\t\\tpts = 0\\n\\t\\t\\tfor loc in diag:\\n\\t\\t\\t\\tif self.board[loc[0]][loc[1]] == self.marker:\\n\\t\\t\\t\\t\\tpts+=1\\n\\t\\t\\tif pts == 3:\\n\\t\\t\\t\\tprint('WE WON')\\n\\t\\t\\t\\treturn True\",\n \"def isValidCompatible(cls,root):\\n valid = True\\n # the order of node types in chains is restricted\\n # (this would be easier if the data was in a Corpus-instance)\\n allowed = NX.XDiGraph(selfloops=True)\\n\\n # continue from here!\\n allowed.add_edge('Physical','Physical')\\n allowed.add_edge('Property','Physical')\\n allowed.add_edge('Process','Physical')\\n allowed.add_edge('Regulation','Physical')\\n\\n allowed.add_edge('Property','Property')\\n allowed.add_edge('Process','Property')\\n allowed.add_edge('Regulation','Property')\\n\\n allowed.add_edge('Property','Process')\\n# allowed.add_edge('Process','Process')\\n allowed.add_edge('Regulation','Process')\\n\\n allowed.add_edge('Property','Regulation')\\n# allowed.add_edge('Process','Regulation')\\n allowed.add_edge('Regulation','Regulation')\\n\\n mapping = {}\\n for a in root.find(\\\"ontologies\\\").findall(\\\"ontology\\\"):\\n if a.attrib['id']=='interaction':\\n for x in a.getiterator(\\\"ontnode\\\"):\\n if x.attrib.has_key('effect') and x.attrib['effect'].endswith('regulation'):\\n t = 'Regulation'\\n else:\\n t = x.attrib['onttype']\\n mapping[x.attrib['id']] = t\\n \\n for a in root.getiterator(\\\"relannotation\\\"):\\n t2type = dict( [(x.attrib['id'],x.attrib['type'])\\n for x in a.findall(\\\"reltoken\\\")] )\\n n2t = dict( [(x.attrib['id'],x.attrib['token'])\\n for x in a.findall(\\\"relnode\\\")] )\\n for x in a.findall(\\\"reledge\\\"):\\n bt = t2type[n2t[x.attrib['bgn']]]\\n et = t2type[n2t[x.attrib['end']]]\\n bgn = mapping[bt]\\n end = mapping[et]\\n if not allowed.has_edge(bgn,end):\\n printError(cls,inspect.stack()[1][3],\\n \\\"%s -- %s (%s) -> %s (%s) is not a valid edge\\\"%\\n (x.attrib['id'].split('.')[1],bgn,bt,end,et))\\n valid = False\\n \\n return(valid)\",\n \"def check_regularity(edges):\\n for a, b in edges:\\n counter_a = 0\\n counter_b = 0\\n for x, y in edges:\\n if a == x or a == y:\\n counter_a += 1\\n if b == x or b == y:\\n counter_b += 1\\n assert (counter_a > 0) and (counter_b > 0)\\n if (counter_a == 1) or (counter_b == 1):\\n raise Exception(\\\"Boundary is not closed.\\\")\\n if (counter_a > 2) or (counter_b > 2):\\n raise Exception(\\\"More than two edges share a node.\\\")\",\n \"def nodes_are_interconnected(graph, nodes):\\n \\n nid_list = []\\n for node in nodes:\\n if hasattr(node, 'nid'):\\n nid_list.append(node.nid)\\n elif node in graph.nodes:\\n nid_list.append(node)\\n else:\\n raise 'Node not in graph {0}'.format(node)\\n\\n nid_list = set(nid_list)\\n\\n collection = []\\n for nid in nid_list:\\n query = set(graph.adjacency[nid] + [nid])\\n collection.append(query.intersection(nid_list) == nid_list)\\n \\n return all(collection)\",\n \"def check_nodes(self) -> bool:\\n # check the input-output consistency\\n for op_name in self.__ops:\\n op = cast(Operator, self.__ops[op_name])\\n inputs: Dict[str, Operator] = op.input_ops\\n for i in inputs.values():\\n if op not in i.output_op_list:\\n return False\\n\\n return True\",\n \"def hasNoDoubleVertices(self):\\n assert all(self.vertices.count(v) == 1 for v in self.vertices)\\n return (all(all(v1 == v2 or v1.dist(v2) > COMPARISON_EPSILON for v2 in self.vertices)\\n for v1 in self.vertices) and\\n all(self.vertices.count(v) == 1 for v in self.vertices))\",\n \"def haveNoSameEdges(seg1,seg2,segmentsMeta):\\n seg1Edges = segmentsMeta['edges'][seg1]\\n seg2Edges = segmentsMeta['edges'][seg2]\\n return not any(a==b for a in seg1Edges for b in seg2Edges)\",\n \"def connected(self, x, y):\\n\\n return self.__find_root(x) == self.__find_root(y)\",\n \"def test_is_strongly_connected(self):\\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\\n assert_true(is_strongly_connected(G))\",\n \"def is_connected(object_one, object_two):\\n\\n for vert_one in object_one.Vertexes:\\n for vert_two in object_two.Vertexes:\\n if (vert_one.X == vert_two.X) and (vert_one.y == vert_two.y):\\n return True\\n\\n return False\",\n \"def consistent(h, phi):\\n for n in h: # for each node in h\\n if phi(n) in h and phi(n) not in h:\\n return False\\n return True\",\n \"def AreConnected(self, node1_idx, node2_idx):\\n for n in self.nodes:\\n if n.index == node1_idx:\\n a = n\\n elif n.index == node2_idx:\\n b = n\\n\\n return ((b.index in a.neighbours) and (a.index in b.neighbours))\",\n \"def connected(self, avoid=set()):\\n if len(self) <= 1:\\n return True\\n cover = set()\\n queue = {(self.nodes() - avoid).pop()} # Take some element not being avoided\\n while queue:\\n new = queue.pop()\\n cover.add(new)\\n for adjacent in new.parents() | new.children():\\n if not (adjacent in cover or adjacent in avoid):\\n queue.add(adjacent)\\n if len(cover) == len(self) - len(avoid):\\n return True\\n else:\\n return False\",\n \"def check(self, expected, debug=True):\\r\\n for v1, v2, go in expected:\\r\\n for gj, oj in go:\\r\\n r1 = is_same_graph(v1, v2, givens=gj, debug=debug)\\r\\n assert r1 == oj\\r\\n r2 = is_same_graph(v2, v1, givens=gj, debug=debug)\\r\\n assert r2 == oj\",\n \"def test_consistent_ids(self) -> None:\\n bnode = BNode()\\n g0_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Golan Trevize\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n bnode = BNode()\\n g1_ts: _TripleSet = {\\n (bnode, FOAF.name, Literal(\\\"Janov Pelorat\\\")),\\n (bnode, RDF.type, FOAF.Person),\\n }\\n\\n g0 = Graph()\\n g0 += g0_ts\\n cg0 = to_canonical_graph(g0)\\n cg0_ts = GraphHelper.triple_set(cg0)\\n\\n g1 = Graph()\\n g1 += g1_ts\\n cg1 = to_canonical_graph(g1)\\n cg1_ts = GraphHelper.triple_set(cg1)\\n\\n assert cg0_ts.issubset(\\n cg1_ts\\n ), \\\"canonical triple set cg0_ts should be a subset of canonical triple set cg1_ts\\\"\",\n \"def isIsosceles(self):\\n\\t\\treturn self.a == self.b or self.a == self.c or self.b == self.c\",\n \"def validate(self, fgraph):\\r\\n\\r\\n if self.destroyers:\\r\\n ords = self.orderings(fgraph)\\r\\n\\r\\n if _contains_cycle(fgraph, ords):\\r\\n raise InconsistencyError(\\\"Dependency graph contains cycles\\\")\\r\\n else:\\r\\n #James's Conjecture:\\r\\n #If there are no destructive ops, then there can be no cycles.\\r\\n pass\\r\\n return True\",\n \"def mayConnect(self, from_node, to_node):\\n if from_node in self.graph and to_node in self.graph[from_node]:\\n # Connection already exists\\n return False\\n ret = True\\n self.connect(from_node, to_node)\\n visited = [False] * self.num_vertices\\n for i in range(self.num_vertices):\\n if not visited[i]:\\n if self.hasCycle(i, visited, -1):\\n ret = False\\n break\\n self.disconnect(from_node, to_node)\\n return ret\",\n \"def feature_two(ds, tup):\\n # try:\\n # if (nx.shortest_path_length(G, frm, to) == 2):\\n # o2.write(\\\"trusted\\\\n\\\")\\n # else:\\n # o2.write(\\\"unverified\\\\n\\\")\\n # except:\\n # o2.write(\\\"unverified\\\\n\\\")\\n\\n A_child = ds[tup[0]]\\n C_child = ds[tup[1]]\\n return ((len(A_child.intersection(C_child)) > 0) | (tup[0] in ds[tup[1]]))\",\n \"def graph_is_connected(node_count, edges):\\n\\n disjoint_set = disjoint.DisjointSet(node_count + 1)\\n\\n for a, b in edges:\\n disjoint_set.union(a, b)\\n\\n # Check if all nodes are part of the same set\\n\\n root = disjoint_set.root(1)\\n\\n for i in range(2, node_count + 1):\\n if disjoint_set.root(i) != root:\\n return False\\n\\n return True\",\n \"def check_all_constraints(csp) :\\n\\n for constraint in csp.get_all_constraints():\\n assigned1 = csp.get_assigned_value(constraint.var1)\\n assigned2 = csp.get_assigned_value(constraint.var2)\\n check = constraint.check(assigned1,assigned2)\\n if check==False and assigned1!=None and assigned2!=None:\\n return False \\n return True\",\n \"def validate(self, fgraph):\\r\\n\\r\\n if self.destroyers:\\r\\n ords = self.orderings(fgraph)\\r\\n\\r\\n if _contains_cycle(fgraph, ords):\\r\\n raise InconsistencyError(\\\"Dependency graph contains cycles\\\")\\r\\n else:\\r\\n #James's Conjecture:\\r\\n #If there are no destructive ops, then there can be no cycles.\\r\\n pass\\r\\n return True\",\n \"def is_valid_adjacency_matrix(connections, num_intermediate, num_input, num_output):\\n\\n num_emitting = num_intermediate + num_input\\n num_receiving = num_intermediate + num_output\\n\\n if connections.size(0) < num_receiving:\\n return False\\n if connections.size(1) < num_emitting:\\n return False\\n\\n embedded_intermediate_size = connections.size(0) - num_output\\n #check that dimensions of the connectivity tensor are consistent with single fixed intermediate size\\n if embedded_intermediate_size < 0 or embedded_intermediate_size != connections.size(1) - num_input:\\n return False\\n\\n # check left-justified\\n if connections[num_receiving:, :].sum().item() > 0:\\n return False\\n if connections[:, num_emitting:].sum().item() > 0:\\n return False\\n # check that vertices only receive input from ancestors\\n for i in range(num_receiving):\\n if connections[i, i+ num_input:].sum().item() > 0:\\n return False\\n return True\",\n \"def valid_colset_pair((cset1, cset2), pairedcols):\\n c1a, cia, cna = cset1\\n c1b, cib, cnb = cset2\\n seta = set([c1a, cna]) | cia\\n setb = set([c1b, cnb]) | cib\\n if not seta.isdisjoint(setb):\\n for a, b in pairedcols:\\n if cna == a and c1b == b:\\n return False\\n if cnb == a and c1a == b:\\n return False\\n if c1a in setb and cna in setb and not seta <= setb:\\n return False\\n if c1b in seta and cnb in seta and not setb <= seta:\\n return False\\n if cna not in set([cnb]) | cib and cnb not in set([cna]) | cia:\\n return False\\n if c1a not in set([c1b]) | cib and c1b not in set([c1a]) | cia:\\n return False\\n return True\",\n \"def test_reachable_pair(self):\\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\\n assert_true(is_reachable(G, 0, 2))\",\n \"def is_weakly_connected(G):\\n if len(G) == 0:\\n raise nx.NetworkXPointlessConcept(\\n \\\"\\\"\\\"Connectivity is undefined for the null graph.\\\"\\\"\\\")\\n\\n return len(list(weakly_connected_components(G))[0]) == len(G)\",\n \"def contains_edge(self, node, other_node):\\n return \\\\\\n {node.get_name(), other_node.get_name()} in \\\\\\n list([\\n {edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()}\\n for edge in self.get_edges()\\n ]) # return true if there exists an edge between the input nodes and false otherwise\",\n \"def exact_fact_check(self, triple, transitive=False):\\n exists = self.knowledge_graph.check_triple_object_existence(triple, transitive)\\n if exists is True:\\n return 'exists', []\\n conflicts = self.knowledge_graph.get_triples(triple.subject, triple.relation, transitive)\\n if conflicts is not None:\\n return 'conflicts', conflicts\\n # The following checks triples with the same subject and object, but different relation. Are those conflict?\\n # if conflicts is None:\\n # conflicts = []\\n # for obj in triple.objects:\\n # relations = self.knowledge_graph.get_relation_triples(triple.subject, obj)\\n # if relations is not None:\\n # conflicts += relations\\n # if len(conflicts) > 0:\\n # return 'conflicts', conflicts\\n return 'none', []\",\n \"def is_crossed(self):\\n left_boundary_clusters = np.extract(self.cluster[0] > 0,\\n self.cluster[0])\\n right_boundary_clusters = np.extract(self.cluster[-1] > 0,\\n self.cluster[-1])\\n return np.in1d(left_boundary_clusters, right_boundary_clusters).any()\",\n \"def check_undirected(graph):\\n for node in graph:\\n for neighbor in graph[node]:\\n if node not in graph[neighbor]:\\n return False\\n return True\",\n \"def mismatches(self, sequence, pairs=None):\\n mismatches = 0\\n if pairs is None:\\n try:\\n pairs = sequence.Alphabet.Pairs\\n except AttributeError:\\n pairs = sequence.Pairs\\n \\n for up, down in self.directed():\\n curr = (sequence[up], sequence[down])\\n if curr not in pairs:\\n mismatches += 1\\n return mismatches\",\n \"def is_contradiction(formula: Formula) -> bool:\\n # Task 2.5b\\n return not is_satisfiable(formula)\",\n \"def is_contradiction(formula: Formula) -> bool:\\r\\n # Task 2.5b\\r\\n return not is_satisfiable(formula)\",\n \"def check_perm(tri1,tri2):\\n for t1 in tri1:\\n for t2 in tri2:\\n if t1 == t2:\\n return False\\n return True\",\n \"def verbose_are_connected_recursive(self, person1, person2, seen=None):\\n\\n if not seen:\\n seen = set()\\n\\n if person1 is person2:\\n print(\\\"\\\\nreturning True - {} is {}\\\".format(person1.name, person2.name))\\n return True\\n\\n seen.add(person1) # Keep track that we've visited here\\n print(\\\"adding\\\", person1)\\n\\n for person in person1.adjacent:\\n\\n if person not in seen:\\n\\n print(\\\"calling method on {}'s cohabitant {} with {}\\\".format(person1.name, person.name, person2.name))\\n if self.verbose_are_connected_recursive(person, person2, seen):\\n print(\\\"\\\\nreturning True from checking {}\\\".format(person.name))\\n return True\\n\\n print(\\\"returning False from checking {}\\\".format(person1.name))\\n return False\",\n \"def test_case7(self):\\n\\n graph3 = self.graph1.merge(self.graph2)\\n\\n expected = {'supervisor1':['student1','student2','student4'],'supervisor2':['student4','student1','student3'],'supervisor3':['student3','student2']}\\n\\n result = True\\n\\n for sup in expected:\\n for stu in expected[sup]:\\n if not graph3.isEdge(sup,stu):\\n result = False\\n break\\n\\n self.assertTrue(result)\",\n \"def validate_conn(self, solution):\\r\\n\\r\\n active_nodes = [idx for idx, value in enumerate(solution) # remove not included nodes in solution\\r\\n if value != 0 and idx not in self.dead_nodes and self.network.get_node(idx).energy >= cf.COMMUNICATION_ENERGY]\\r\\n active_nodes.append(-1) # add a sink node \\r\\n visited = self.DFS(self.network_graph, active_nodes[0], active_nodes)\\r\\n if len(visited) == len(active_nodes):\\r\\n return True\\r\\n else:\\r\\n return False\",\n \"def test_same_node_is_reachable(self):\\n # G is an arbitrary tournament on ten nodes.\\n G = DiGraph(sorted(p) for p in combinations(range(10), 2))\\n assert_true(all(is_reachable(G, v, v) for v in G))\",\n \"def check_symmetric(adj : np.ndarray, tol : float = 1e-8) -> bool:\\n return np.all(np.abs(adj-adj.T) < tol)\",\n \"def check_relations(self, relations):\\n if self.debug:\\n print(\\\"Checking relations\\\")\\n result = False\\n work_relations = []\\n\\n # Eliminate unnecessary(duplicated) clauses\\n if relations[\\\"is_derived_from\\\"]:\\n relations[\\\"has_derived_form\\\"] = True\\n relations[\\\"is_derived_from\\\"] = False\\n if relations[\\\"etymology\\\"]:\\n relations[\\\"etymological_origin_of\\\"] = True\\n relations[\\\"etymology\\\"] = False\\n\\n for relation in relations:\\n if relations[relation]:\\n result = True\\n work_relations.append(relation)\\n return result, work_relations\",\n \"def compare(self, node) -> bool:\\n\\t\\t# No conflicts, Return True\\n\\t\\treturn True\",\n \"def is_good_cyc(path, G, bamfile):\\n\\n sing_nodes = set()\\n for node in path:\\n if node[-1] == \\\"'\\\": node = node[:-1]\\n sing_nodes.add(node)\\n if len(sing_nodes)==0: return True\\n\\n non_path_dominated_nodes = 0\\n\\n for nd in sing_nodes:\\n mate_tigs = get_contigs_of_mates(nd, bamfile, G)\\n # NOTE: ^ this only gets mates that are reachable from nd in G\\n logger.info(\\\"\\\\tNode: %s\\\" % nd)\\n logger.info(\\\"\\\\t\\\\tMates: %s\\\" % \\\", \\\".join(mate_tigs))\\n\\n # need to check against F and R versions of path nodes\\n path_rc = [rc_node(x) for x in path]\\n num_mates_in_path = sum([1 for x in mate_tigs if (x in path or x in path_rc)])\\n num_mates_not_in_path = len(mate_tigs)-num_mates_in_path\\n if num_mates_in_path < num_mates_not_in_path:\\n ########### if len(mate_tigs)>1 and num_mates_in_path < num_mates_not_in_path:\\n non_path_dominated_nodes += 1\\n if float(non_path_dominated_nodes)/float(len(sing_nodes)) > PARAMS.GOOD_CYC_DOMINATED_THRESH:\\n logger.info(\\\"Too many nodes with majority of mates not on path\\\")\\n return False\\n else: return True\",\n \"def pair_is_consistent(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n\\n if 1 != len(relations):\\n return False\\n\\n return list(relations)[0]\",\n \"def has_cycle(graph):\\n ds = DisjointSet()\\n\\n # creates a set of all graph nodes\\n node_set = set()\\n for edge in graph:\\n node_set.add(edge.node1)\\n node_set.add(edge.node2)\\n\\n for item in node_set:\\n ds.make_set(item)\\n\\n for edge in graph:\\n same_set = ds.union(edge.node1, edge.node2)\\n if same_set:\\n return True\\n\\n return False\",\n \"def can_relax_constraints(self):\\n if len(self.mand_classroom_constraints) == 0:\\n if len(self.high_classroom_constraints) > 0:\\n return True\\n else:\\n for cc in self.low_classroom_constraints:\\n if cc.can_relax_constraints():\\n return True\\n\\n if len(self.mand_timeblock_ids) == 0:\\n if len(self.high_timeblock_ids) > 0:\\n return True\\n\\n return False\",\n \"def cross_transitivity_sparse(self, node_list1, node_list2):\\n cross_degree = self.cross_degree(node_list1, node_list2)\\n\\n # Get sparse adjacency matrix\\n A = self.sp_A[node_list1+node_list2, :][:, node_list1+node_list2]\\n # Get subnetwork sizes\\n N1, N2 = len(node_list1), len(node_list2)\\n # Initialize\\n cross_transitivity = 0.0\\n # Set counter\\n counter_triangles = 0.0\\n counter_triples = 0.0\\n # Calculate cross transitivity from subnetwork 1 to subnetwork 2\\n # Loop over nodes in subnetwork 1\\n for i in range(N1):\\n node1 = i\\n if cross_degree[i] > 1:\\n # Loop over unique pairs of nodes in subnetwork 2\\n for j in range(N1, N1+N2):\\n node2 = j\\n for k in range(N1, j):\\n node3 = k\\n if A[node1, node2] == 1 and A[node1, node3] == 1:\\n counter_triples += 1\\n if A[node2, node3] == 1:\\n counter_triangles += 1\\n\\n if counter_triples:\\n cross_transitivity = counter_triangles / counter_triples\\n return cross_transitivity\",\n \"def identical_cds(sc1,sc2):\\n # Input 2 identical segment chains, return True if cds the same\\n if sc1.covers(sc2) and sc2.covers(sc1):\\n return True\\n else:\\n return False\",\n \"def check_cons(term, cons):\\n res = True\\n for constr in cons:\\n if constr.issubset(term):\\n res = False\\n break\\n return res\",\n \"def enforce_node_consistency(self):\\n # Loop over each variable (space for word) in the crossword\\n # Use copy to prevent domains from being modified while looping\\n for var in self.domains.copy():\\n # Get all unary constraints for this variable\\n for value in self.domains[var].copy():\\n # Check if the value is consistent with all unary constraints\\n if len(value) != var.length:\\n # If not, remove the value from the domain\\n self.domains[var].remove(value)\\n # No return value is necessary\",\n \"def is_connected_same_node(graph, node_u, node_v):\\n for out_neighbor_u in graph.get_deductive_out_neighbors(node_u):\\n for out_neighbor_v in graph.get_deductive_out_neighbors(node_v):\\n if out_neighbor_u == out_neighbor_v:\\n return True\\n return False\",\n \"def victory_checker() -> bool:\\r\\n conflict_check()\\r\\n for x in range(shape):\\r\\n for y in range(shape):\\r\\n if conflict_space[x, y] != 0:\\r\\n return False\\r\\n if separation_crawler(False):\\r\\n return False\\r\\n return True\",\n \"def check_all_constraints(csp) :\\n constraints=csp.get_all_constraints()\\n for constraint in constraints:\\n var1 = constraint.var1\\n var2 = constraint.var2\\n val1=csp.get_assigned_value(var1)\\n val2=csp.get_assigned_value(var2)\\n if val1!=None and val2!=None:\\n if not constraint.check(val1,val2):\\n return False\\n return True\",\n \"def all_covered(matches, molecule) -> bool:\\n # check atoms\\n for i in range(molecule.n_atoms):\\n assert (i, ) in matches\\n # check bonds\\n for bond in molecule.bonds:\\n bond = (bond.atom1_index, bond.atom2_index)\\n assert bond in matches or tuple(reversed(bond)) in matches\\n # check angles\\n for angle in molecule.angles:\\n angle = tuple([atom.molecule_atom_index for atom in angle])\\n assert angle in matches or tuple(reversed(angle)) in matches\\n # check torsions\\n for torsion in molecule.propers:\\n dihedral = tuple([atom.molecule_atom_index for atom in torsion])\\n assert dihedral in matches or tuple(reversed(dihedral)) in matches\\n\\n return True\",\n \"def is_exceptional(self):\\n G = self.poset().hasse_diagram()\\n for x in G:\\n nx = list(G.neighbors_out(x))\\n nx.append(x)\\n if min(nx) < x and max(nx) > x:\\n return False\\n return True\",\n \"def dist(self, one, two):\\n return sum((one[0] != two[0], one[1] != two[1]))\",\n \"def nsi_cross_closeness_centrality(self, node_list1, node_list2):\\n shortest_paths = self.path_lengths()\\n node_weights = self.node_weights\\n\\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\\n\\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\\n W = sum(node_weights[node_list2])\\n return W / np.dot(nsi_cross_paths, node_weights[node_list2])\",\n \"def IsCyclic(self):\\n\\n visited = [False for i in range(self.NodesCount())]\\n \\n for idx in range(1, self.NodesCount()+1): \\n if not visited[idx-1]: \\n if self.IsCyclicRec(idx, visited, -1): \\n return True\\n return False\",\n \"def valid_colset_comb(prod, pairedcols):\\n for c1, ci, cn in prod:\\n cols = set([c1, cn]) | ci\\n for a, b in pairedcols:\\n if (a in ci and b not in ci and b != cn) or (b in ci and a not in ci and a != c1):\\n return False\\n if (a == c1 and b not in ci) or (a == cn and b in cols):\\n return False\\n if (b == c1 and a in cols) or (b == cn and a not in ci):\\n return False\\n return all(valid_colset_pair(x, pairedcols) for x in combinations(prod, 2))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68102324","0.6214052","0.6207057","0.60906833","0.6065176","0.60568976","0.6026552","0.6008109","0.59604144","0.59581804","0.59490097","0.5934767","0.5910104","0.59072256","0.5901164","0.5900084","0.58665067","0.58433616","0.5840681","0.5824252","0.5824074","0.5818633","0.57808894","0.5774537","0.5769276","0.5736746","0.57347584","0.5721173","0.57204604","0.5719087","0.57184476","0.5705484","0.5690299","0.5687697","0.5687037","0.5685037","0.56842536","0.5682825","0.5680984","0.5675163","0.5651126","0.5648773","0.5641403","0.5640537","0.5636808","0.56228983","0.56179816","0.5614773","0.56133974","0.56074625","0.56057835","0.55976796","0.558928","0.5588176","0.55856174","0.55771804","0.5572077","0.55639064","0.5562854","0.5551567","0.5550769","0.5550286","0.5548965","0.5543802","0.55369806","0.55343145","0.55334795","0.55311275","0.5523003","0.55191654","0.5515714","0.5514623","0.5509379","0.55026644","0.5499654","0.5497921","0.5493394","0.54897517","0.5488576","0.5481201","0.5479468","0.54730046","0.54604965","0.5453754","0.54535025","0.5452682","0.5448561","0.54482424","0.54430777","0.54375166","0.54259723","0.5412422","0.5410087","0.5409021","0.5408073","0.54077435","0.53916734","0.53914565","0.53768957","0.53758365"],"string":"[\n \"0.68102324\",\n \"0.6214052\",\n \"0.6207057\",\n \"0.60906833\",\n \"0.6065176\",\n \"0.60568976\",\n \"0.6026552\",\n \"0.6008109\",\n \"0.59604144\",\n \"0.59581804\",\n \"0.59490097\",\n \"0.5934767\",\n \"0.5910104\",\n \"0.59072256\",\n \"0.5901164\",\n \"0.5900084\",\n \"0.58665067\",\n \"0.58433616\",\n \"0.5840681\",\n \"0.5824252\",\n \"0.5824074\",\n \"0.5818633\",\n \"0.57808894\",\n \"0.5774537\",\n \"0.5769276\",\n \"0.5736746\",\n \"0.57347584\",\n \"0.5721173\",\n \"0.57204604\",\n \"0.5719087\",\n \"0.57184476\",\n \"0.5705484\",\n \"0.5690299\",\n \"0.5687697\",\n \"0.5687037\",\n \"0.5685037\",\n \"0.56842536\",\n \"0.5682825\",\n \"0.5680984\",\n \"0.5675163\",\n \"0.5651126\",\n \"0.5648773\",\n \"0.5641403\",\n \"0.5640537\",\n \"0.5636808\",\n \"0.56228983\",\n \"0.56179816\",\n \"0.5614773\",\n \"0.56133974\",\n \"0.56074625\",\n \"0.56057835\",\n \"0.55976796\",\n \"0.558928\",\n \"0.5588176\",\n \"0.55856174\",\n \"0.55771804\",\n \"0.5572077\",\n \"0.55639064\",\n \"0.5562854\",\n \"0.5551567\",\n \"0.5550769\",\n \"0.5550286\",\n \"0.5548965\",\n \"0.5543802\",\n \"0.55369806\",\n \"0.55343145\",\n \"0.55334795\",\n \"0.55311275\",\n \"0.5523003\",\n \"0.55191654\",\n \"0.5515714\",\n \"0.5514623\",\n \"0.5509379\",\n \"0.55026644\",\n \"0.5499654\",\n \"0.5497921\",\n \"0.5493394\",\n \"0.54897517\",\n \"0.5488576\",\n \"0.5481201\",\n \"0.5479468\",\n \"0.54730046\",\n \"0.54604965\",\n \"0.5453754\",\n \"0.54535025\",\n \"0.5452682\",\n \"0.5448561\",\n \"0.54482424\",\n \"0.54430777\",\n \"0.54375166\",\n \"0.54259723\",\n \"0.5412422\",\n \"0.5410087\",\n \"0.5409021\",\n \"0.5408073\",\n \"0.54077435\",\n \"0.53916734\",\n \"0.53914565\",\n \"0.53768957\",\n \"0.53758365\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62543714"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20172,"cells":{"query":{"kind":"string","value":"Iterates over contradictory node pairs in the graph based on their causal relationships"},"document":{"kind":"string","value":"def get_contradictory_pairs(graph):\n for u, v in _iter_pairs(graph):\n if pair_has_contradiction(graph, u, v):\n yield u, v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_successors(self, node):\n succs = []\n parent_state = self.node_to_state(node)\n for it in self.children:\n child_node = (node[0] + it[0], node[1] + it[1])\n child_state = self.node_to_state(child_node)\n edge = self.interpolate(parent_state, child_state, self.distance_bw_states(parent_state, child_state)/self.path_resolution)\n succs.append([child_node, edge])\n return succs","def cohen_sadeh(prelations):\n # Adaptation to avoid multiple end nodes\n successors = graph.reversed_prelation_table(prelations)\n end_act = graph.ending_activities(successors)\n\n #Step 1. Construct work table with Immediate Predecessors\n Columns = namedlist.namedlist('Columns', ['pre', 'blocked', 'dummy', 'suc', 'start_node', 'end_node'])\n # [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node]\n # Blocked = (False or Activity with same precedents)\n work_table = {}\n for act, predecessors in prelations.items():\n work_table[act] = Columns(set(predecessors), False, False, None, None, None)\n\n# print \"\\n--- Step 1 ---\"\n# __print_work_table(work_table)\n\n #Step 2. Identify Identical Precedence Constraint of Diferent Activities\n visited_pred = {}\n for act, columns in work_table.items():\n pred = frozenset(columns.pre)\n if pred not in visited_pred:\n visited_pred[pred] = act\n else:\n columns.blocked = visited_pred[pred]\n\n# print \"\\n--- Step 2 ---\"\n# __print_work_table(work_table)\n\n\n #Step 3. Identify Necessary Dummy Arcs\n dups = set()\n visited_act = set()\n for columns in work_table.values():\n if not columns.blocked:\n for act in columns.pre:\n if act in visited_act:\n dups.add(act)\n visited_act.add(act)\n\n# print \"\\n--- Step 3.1 ---\"\n# print dups\n\n\n #Step 3.2, 3.3 and 4. Create rows and information for Dummy Arcs\n dummy_counter = collections.Counter()\n for _, columns in work_table.items():\n # Avoid blocked\n if not columns.blocked:\n predecessors = columns.pre\n if len(predecessors) > 1:\n for pre in list(predecessors):\n if pre in dups:\n predecessors.remove(pre)\n dummy_name = pre + '-d' + str(dummy_counter[pre])\n dummy_counter[pre] += 1\n predecessors.add(dummy_name)\n work_table[dummy_name] = Columns(set([pre]), False, True, None, None, None)\n\n# print \"\\n--- Step 4 ---\"\n# __print_work_table(work_table)\n\n\n #Step 5. Creating nodes\n node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging\n for act, columns in work_table.items():\n if not columns.dummy and not columns.blocked:\n columns.start_node = node\n node += 1\n\n# print \"\\n--- Step 5a ---\"\n# __print_work_table(work_table)\n\n for act, columns in work_table.items():\n if not columns.dummy and columns.blocked:\n columns.start_node = work_table[columns.blocked].start_node\n\n# print \"\\n--- Step 5b ---\"\n# __print_work_table(work_table)\n\n\n #Step 6. Associate activities with their end nodes\n # (a) find one non-dummy successor for each activity\n for act, columns in work_table.items():\n for suc, suc_columns in work_table.items():\n if not suc_columns.dummy and not suc_columns.blocked:\n if act in suc_columns.pre:\n columns.suc = suc\n break\n\n# print \"\\n--- Step 6a ---\"\n# __print_work_table(work_table)\n\n # (b) find end nodes\n graph_end_node = node # Reserve one node for graph end \n node += 1\n for act, columns in work_table.items():\n suc = columns.suc\n if suc:\n columns.end_node = work_table[suc].start_node\n else:\n # Create needed end nodes, avoiding multiple graph end nodes (adaptation)\n if act in end_act:\n columns.end_node = graph_end_node\n else:\n columns.end_node = node \n node += 1\n\n# print \"\\n--- Step 6b ---\"\n# __print_work_table(work_table)\n\n\n #Step 7. Associate dummy arcs with start nodes\n for act, columns in work_table.items():\n if columns.dummy:\n pred = iter(columns.pre).next()\n start_node = work_table[pred].end_node\n columns.start_node = start_node\n\n# print \"\\n--- Step 7 ---\"\n# __print_work_table(work_table)\n\n\n #Step 8. Generate the graph\n pm_graph = pert.PertMultigraph()\n for act, columns in work_table.items():\n _, _, dummy, _, start, end = columns\n pm_graph.add_arc((start, end), (act, dummy))\n\n p_graph = pm_graph.to_directed_graph()\n return p_graph.renumerar()","def calc_cc(graph):\n\tclustering_coeffs = {}\n\tfor node in graph.nodes():\n\t\tclustering_coeffs[node] = { \"cc\" : nx.clustering(graph, node)}\n\tnx.set_node_attributes(graph, clustering_coeffs)","def cc_visited(ugraph):\n remain = set(ugraph.keys())\n conn_comp = []\n while remain:\n node = remain.pop()\n visited = bfs_visited(ugraph, node)\n conn_comp.append(visited)\n remain = remain.difference(visited)\n return conn_comp","def cc_visited(ugraph):\r\n\tremaining_node = ugraph.keys()\t\t#The keys are accessible directly.\r\n\t\r\n\tcon_com = [] #connected component\r\n\twhile len(remaining_node) != 0 :\r\n\t\tnode = random.choice(remaining_node)\r\n\t\tvisited = bfs_visited(ugraph,node)\r\n\t\tcon_com.append(visited)\r\n\t\tfor item in visited:\r\n\t\t\tremaining_node.remove(item)\r\n\treturn con_com","def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target","def cooccuranceBlock(ntupleSet,nodeList):\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\n for ntuple in ntupleSet:\n for nodeInTuple in ntuple:\n nodesPerNode[nodeInTuple].extend(ntuple)\n \n for a,v in nodesPerNode.iteritems():\n differentNodes = set(v).difference(set([a]))\n NumberdifferentNodes = len(differentNodes) \n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\n \n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))","def cc_visited(ugraph):\n \n remaining = set(ugraph.keys())\n ccomp = []\n while len(remaining) > 0:\n node = remaining.pop()\n visited = bfs_visited(ugraph,node)\n ccomp.append(visited)\n remaining.difference_update(visited)\n \n return ccomp","def betweenness_centrality(self, node):\n l=[]\n b=0\n for i in vertices:\n if i!=node:\n l.append(i)\n comb=list(itertools.combinations(l,2))\n \n for c in comb:\n count=0\n l=self.all_shortest_paths(c[0],c[1])\n if l==None:\n print(c)\n for i in range(len(l)):\n if node in l[i]:\n count+=1\n b+=count/len(l)\n\n return b","def connectivity_graph(rdm):\n rdm = _rd_chem.AddHs(rdm)\n atms = rdm.GetAtoms()\n bnds = rdm.GetBonds()\n asbs = dict(enumerate((rda.GetSymbol(), 0, None) for rda in atms))\n cnns = {frozenset([rdb.GetBeginAtomIdx(), rdb.GetEndAtomIdx()]): (1, None)\n for rdb in bnds}\n return (asbs, cnns)","def associate_successors(graph, node=\"\"):\n return {\n \"successors\": [\n {\n \"source\": node,\n \"target\": succ,\n \"edge_attribute\": graph.succ[node][succ][\"edge_attribute\"],\n }\n for succ in graph.succ[node]\n ]\n }","def test_cc_visited(self):\n graph1 = {0: set()}\n self.assertEqual(p.cc_visited(graph1), [set([0])])\n\n graph2 = {0: set([1]), 1: set([0])}\n self.assertEqual(p.cc_visited(graph2), [set([0,1])])\n\n graph3 = {0: set([]), 1: set([])}\n self.assertItemsEqual(p.cc_visited(graph3), [set([0]), set([1])])\n\n graph4 = {0: set([]), 1: set([2]), 2: set([1])}\n self.assertItemsEqual(p.cc_visited(graph4), [set([0]), set([1,2])])\n\n graph6 = {\"a\": set([]), \"b\": set([\"c\"]), \"c\": set([\"d\",\"b\"]), \"d\":set([\"e\", \"c\"]), \"e\":set([\"d\"]) }\n self.assertItemsEqual(p.cc_visited(graph6), [set([\"a\"]), set([\"b\",\"c\", \"d\", \"e\"])])","def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v","def transitive_closure(self, term_id_list):\n\n edges = set()\n visited = set(term_id_list)\n\n for term_id in term_id_list:\n current_term = term_id\n\n while current_term != 'KEGG Pathway':\n next_term = self.term2parent[current_term]\n edges.add((current_term, 'is_a', next_term))\n visited.add(current_term)\n current_term = next_term\n\n return visited, edges","def condensation(G):\n scc = strongly_connected_components(G)\n mapping = dict([(n,tuple(sorted(c))) for c in scc for n in c])\n cG = nx.DiGraph()\n for u in mapping:\n cG.add_node(mapping[u])\n for _,v,d in G.edges_iter(u, data=True):\n if v not in mapping[u]:\n cG.add_edge(mapping[u], mapping[v])\n return cG","def strongly_connected_components(self):\n for node in self.graph:\n node.data.visited = False\n\n reverse_graph = self.reverse_graph()\n dfs_reverse_graph = DFS(reverse_graph.graph, generate_stack=True)\n dfs_reverse_graph.search()\n\n dfs_graph = DFS(self.graph, generate_scc=True)\n\n while dfs_reverse_graph.stack:\n node = self.graph.get_node(dfs_reverse_graph.stack.top_pop())\n if not node.data.visited:\n dfs_graph.strongly_connected_components.append([])\n dfs_graph.num_scc += 1\n dfs_graph.explore(node)\n return dfs_graph.num_scc, dfs_graph.strongly_connected_components","def combinations(graph, all_combs, all_costs, all_values, start, prev_cost, prev_value, prev_nodes):\n for ii in range(start, graph.size):\n # combination\n nodes = prev_nodes + [ii]\n all_combs.append(nodes)\n # cost\n cost = prev_cost + graph.node_weights[ii][0]\n all_costs.append(cost)\n # value\n value = prev_value + graph.node_weights[ii][1] - graph.node_weights[ii][0]\n for node in prev_nodes: # complementarity\n for adjacent in graph.graph[node]:\n if adjacent[0] == ii:\n value += adjacent[1]\n all_values.append(value)\n # recurse\n combinations(graph, all_combs, all_costs, all_values, ii+1, cost, value, nodes)","def ClusteringTransitivity(graph):\n transitivity = nx.transitivity(graph)\n return transitivity","def coarsen(A, levels, self_connections=False):\n # Function written by M. Defferrard, taken (almost) verbatim, from \n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L5\n graphs, parents = metis(A, levels)\n perms = compute_perm(parents)\n\n for i, A in enumerate(graphs):\n M, M = A.shape\n\n if not self_connections:\n A = A.tocoo()\n A.setdiag(0)\n\n if i < levels:\n A = perm_adjacency(A, perms[i])\n\n A = A.tocsr()\n A.eliminate_zeros()\n graphs[i] = A\n\n# Mnew, Mnew = A.shape\n# print('Layer {0}: M_{0} = |V| = {1} nodes ({2} added),'\n# '|E| = {3} edges'.format(i, Mnew, Mnew-M, A.nnz//2))\n\n\n return graphs, perms[0] if levels > 0 else None","def pair_has_contradiction(graph, u, v):\n relations = get_all_relations(graph, u, v)\n return relation_set_has_contradictions(relations)","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def iterate_connected_atoms(self, atom):\n successors_iter = self._execution_graph.successors_iter\n return _depth_first_iterate(\n self._execution_graph, {\n co.FLOW: successors_iter,\n co.TASK: successors_iter,\n co.RETRY: successors_iter,\n }, successors_iter(atom))","def transitive_reduction(self, sorted_node):\n \n if self.is_cyclic() is False:\n \n visited = set()\n path = []\n\n for i in sorted_node:\n if i not in visited:\n visited = self.transitive_reduction_helper(i, visited, path)\n \n print(\"Transitive reduction is completed.\")\n \n else:\n print(\"Transitive reduction can only be performed on directed acyclic graph.\")","def relation_set_has_contradictions(relations):\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\n return 1 < sum([has_cnc, has_decreases, has_increases])","def cc_visited(ugraph):\n\tremain = []\n\tfor node in ugraph:\n\t\tremain.append(node)\n\tconnected = []\n\twhile remain:\n\t\tvisited = bfs_visited(ugraph, remain[0])\n\t\tconnected.append(visited)\n\t\tremain = [i for i in remain if not i in visited]\n\treturn connected","def indirect(stack):\n g = nx.Graph(stack)\n for group in nx.connected_components(g):\n yield from map(frozenset, combinations(group, 2))","def find_conflicts(graph):\n for node in graph:\n for neighbour in node.neighbours:\n for n in neighbour.neighbours:\n if n is node:\n continue\n _log.info(\"Nodes %s and %s are in conflict.\" % (node, n))\n node.add_conflict_with_node(n)\n n.add_conflict_with_node(node)","def _get_common_neighbour_node_pairs(self):\n node_pairs = []\n for node1 in self.graph.nodes():\n for node2 in self.graph.nodes():\n if node1 != node2:\n neighbour_count = self.neighbour_counts[(node1, node2)]\n if neighbour_count >= 1:\n node_pairs.append((node1, node2))\n return node_pairs","def iter_all_nucleic_acids(self):\n for model in self.model_list:\n for chain in model.chain_list:\n for frag in chain.iter_nucleic_acids():\n yield frag","def cfdProcessNodeTopology(self):\r\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\r\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)","def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))","def aga_contract_graph(adata, min_group_size=0.01, max_n_contractions=1000, copy=False):\n adata = adata.copy() if copy else adata\n if 'aga_adjacency_tree_confidence' not in adata.add: raise ValueError('run tool aga first!')\n min_group_size = min_group_size if min_group_size >= 1 else int(min_group_size * adata.n_smps)\n logg.info('contract graph using `min_group_size={}`'.format(min_group_size))\n\n def propose_nodes_to_contract(adjacency_tree_confidence, node_groups):\n # nodes with two edges\n n_edges_per_seg = np.sum(adjacency_tree_confidence > 0, axis=1).A1\n for i in range(adjacency_tree_confidence.shape[0]):\n if n_edges_per_seg[i] == 2:\n neighbors = adjacency_tree_confidence[i].nonzero()[1]\n for neighbors_edges in range(1, 20):\n for n_cnt, n in enumerate(neighbors):\n if n_edges_per_seg[n] == neighbors_edges:\n logg.msg('merging node {} into {} (two edges)'\n .format(i, n), v=4)\n return i, n\n # node groups with a very small cell number\n for i in range(adjacency_tree_confidence.shape[0]):\n if node_groups[str(i) == node_groups].size < min_group_size:\n neighbors = adjacency_tree_confidence[i].nonzero()[1]\n neighbor_sizes = [node_groups[str(n) == node_groups].size for n in neighbors]\n n = neighbors[np.argmax(neighbor_sizes)]\n logg.msg('merging node {} into {} '\n '(smaller than `min_group_size` = {})'\n .format(i, n, min_group_size), v=4)\n return i, n\n return 0, 0\n\n def contract_nodes(adjacency_tree_confidence, node_groups):\n for count in range(max_n_contractions):\n i, n = propose_nodes_to_contract(adjacency_tree_confidence, node_groups)\n if i != 0 or n != 0:\n G = nx.Graph(adjacency_tree_confidence)\n G_contracted = nx.contracted_nodes(G, n, i, self_loops=False)\n adjacency_tree_confidence = nx.to_scipy_sparse_matrix(G_contracted)\n node_groups[str(i) == node_groups] = str(n)\n for j in range(i+1, G.size()+1):\n node_groups[str(j) == node_groups] = str(j-1)\n else:\n break\n return adjacency_tree_confidence, node_groups\n\n size_before = adata.add['aga_adjacency_tree_confidence'].shape[0]\n adata.add['aga_adjacency_tree_confidence'], adata.smp['aga_groups'] = contract_nodes(\n adata.add['aga_adjacency_tree_confidence'], adata.smp['aga_groups'])\n adata.add['aga_groups_order'] = np.unique(adata.smp['aga_groups'])\n for key in ['aga_adjacency_full_confidence', 'aga_groups_original',\n 'aga_groups_order_original', 'aga_groups_colors_original']:\n if key in adata.add: del adata.add[key]\n logg.info(' contracted graph from {} to {} nodes'\n .format(size_before, adata.add['aga_adjacency_tree_confidence'].shape[0]))\n logg.msg('removed adata.add[\"aga_adjacency_full_confidence\"]', v=4)\n return adata if copy else None","def _create_connections(self):\n self.predecessors = {}\n self.successors = {}\n for nd in self.nodes:\n self.predecessors[nd.name] = []\n self.successors[nd.name] = []\n\n for (nd_out, nd_in) in self.edges:\n self.predecessors[nd_in.name].append(nd_out)\n self.successors[nd_out.name].append(nd_in)","def connecting(node1, node2):\n comp_list = []\n \"\"\":type : list[components.Component]\"\"\"\n if node1 == node2:\n return []\n for comp in node1.connected_comps:\n if comp.neg == node2:\n comp_list.append(comp)\n elif comp.pos == node2:\n comp_list.append(comp)\n return comp_list","def scc(graph, reverse_graph, nodes):\n\n out = defaultdict(list)\n track = Track()\n dfs_loop(reverse_graph, nodes, track)\n sorted_nodes = sorted(track.finish_time,\n key=track.finish_time.get, reverse=True)\n track.current_time = 0\n track.current_source = None\n track.explored = set()\n dfs_loop(graph, sorted_nodes, track)\n for lead, vertex in groupby(sorted(track.leader, key=track.leader.get),\n key=track.leader.get):\n out[lead] = list(vertex)\n\n return out","def narrative_consistency(self, metric='betweenness', nodes=None): # measures centrality\n if metric == 'betweenness':\n vals = nx.betweenness_centrality(self.graph)\n elif metric == 'degree':\n vals = {n[0]: n[1] for n in self.graph.degree()}\n elif metric == 'closeness':\n vals = nx.closeness_centrality(self.graph)\n else:\n vals_b = nx.betweenness_centrality(self.graph)\n vals_d = {n[0]: n[1] for n in self.graph.degree()}\n vals_c = nx.closeness_centrality(self.graph)\n\n min_ = min(vals_b.values())\n delta = max(vals_b.values()) - min_\n vals_b = {k: (v - min_) / delta for k, v in vals_b.items()}\n\n min_ = min(vals_d.values())\n delta = max(vals_d.values()) - min_\n vals_d = {k: (v - min_) / delta for k, v in vals_d.items()}\n\n min_ = min(vals_c.values())\n delta = max(vals_c.values()) - min_\n vals_c = {k: (v - min_) / delta for k, v in vals_c.items()}\n\n vals = {k: (v + vals_b.get(k, 0) + vals_c.get(k, 0)) / 3 for k, v in vals_d.items()}\n\n if nodes is None:\n return sum(-math.log(v) for v in vals.values() if v > 0) / self.graph.number_of_nodes()\n\n return sum(-math.log(v) for k, v in vals.items() if v > 0 and k in nodes) / len(nodes)","def findcc(self):\n for vertex in self.graph.vertices:\n if vertex not in self.preOrderNumbers:\n self.dfs(vertex)\n return self.scComponents","def generate_connectivity_constraint_all(problem):\n\n if problem.num_vars == None:\n problem.compute_num_var()\n\n ret = Constraint()\n\n # Iterator over all (v, t) subsets in the graph\n for b, b_r in enumerate(problem.src):\n # Convert each set in the iterator to (v,t) format\n add_S = map(\n lambda S: list(map(problem.get_time_augmented_n_t, S)),\n problem.powerset_exclude_agent(b_r),\n )\n ret &= generate_connectivity_constraint(problem, [b], add_S)\n\n return ret","def compute_relations(nodes: List[Node]) -> None:\n # Calculate parents\n for node in nodes:\n node.parents = []\n for node in nodes:\n for child in node.children():\n child.parents.append(node)\n\n def compute_dominators(\n entry: Node,\n parents: Callable[[Node], List[Node]],\n dominators: Callable[[Node], Set[Node]],\n immediately_dominates: Callable[[Node], List[Node]],\n set_immediate_dominator: Callable[[Node, Optional[Node]], None],\n ) -> None:\n # See https://en.wikipedia.org/wiki/Dominator_(graph_theory)#Algorithms\n # Note: if `n` is unreachable from `entry`, then *every* node will\n # vacuously belong to `n`'s dominator set.\n for n in nodes:\n dominators(n).clear()\n if n == entry:\n dominators(n).add(n)\n else:\n dominators(n).update(nodes)\n\n changes = True\n while changes:\n changes = False\n for node in nodes:\n if node == entry:\n continue\n nset = dominators(node)\n for parent in parents(node):\n nset = nset.intersection(dominators(parent))\n nset.add(node)\n if len(nset) < len(dominators(node)):\n assert nset.issubset(dominators(node))\n dominators(node).intersection_update(nset)\n changes = True\n\n # Compute immediate dominator, and the inverse relation\n for node in nodes:\n immediately_dominates(node).clear()\n for node in nodes:\n doms = dominators(node).difference({node})\n # If `node == entry` or the flow graph is not reducible, `doms` may be empty.\n # TODO: Infinite loops could be made reducible by introducing\n # branches like `if (false) { return; }` without breaking semantics\n if doms:\n # There should be a unique max `len(dominators(d))` if the flowgraph\n # is reducible. Fall back to largest index for irreducible graphs.\n imdom = max(doms, key=lambda d: (len(dominators(d)), d.block.index))\n immediately_dominates(imdom).append(node)\n set_immediate_dominator(node, imdom)\n else:\n set_immediate_dominator(node, None)\n for node in nodes:\n immediately_dominates(node).sort(key=lambda x: x.block.index)\n\n def _set_immediate_dominator(node: Node, imdom: Optional[Node]) -> None:\n node.immediate_dominator = imdom\n\n def _set_immediate_postdominator(node: Node, impdom: Optional[Node]) -> None:\n node.immediate_postdominator = impdom\n\n entry = nodes[0]\n terminal = nodes[-1]\n assert isinstance(terminal, TerminalNode)\n\n # Compute dominators & immediate dominators\n compute_dominators(\n entry=entry,\n parents=lambda n: n.parents,\n dominators=lambda n: n.dominators,\n immediately_dominates=lambda n: n.immediately_dominates,\n set_immediate_dominator=_set_immediate_dominator,\n )\n\n # Compute postdominators & immediate postdominators\n # This uses the same algorithm as above, but with edges reversed\n compute_dominators(\n entry=terminal,\n parents=lambda n: n.children(),\n dominators=lambda n: n.postdominators,\n immediately_dominates=lambda n: n.immediately_postdominates,\n set_immediate_dominator=_set_immediate_postdominator,\n )\n\n # Iterate over all edges n -> c and check for backedges, which define natural loops\n for node in nodes:\n for child in node.children():\n if child not in node.dominators:\n continue\n # Found a backedge node -> child where child dominates node; child is the \"head\" of the loop\n if child.loop is None:\n child.loop = NaturalLoop(child)\n child.loop.nodes |= {child, node}\n child.loop.backedges.add(node)\n for parent in nodes:\n if reachable_without(parent, node, child):\n child.loop.nodes.add(parent)","def iter_nucleic_acids(self):\n for chain in self.iter_chains():\n for frag in chain.iter_nucleic_acids():\n yield frag","def CirculantGraph(n, adjacency):\n from sage.graphs.graph_plot import _circle_embedding\n\n if not isinstance(adjacency,list):\n adjacency=[adjacency]\n\n G = Graph(n, name=\"Circulant graph (\"+str(adjacency)+\")\")\n _circle_embedding(G, list(range(n)))\n\n for v in G:\n G.add_edges([(v,(v+j)%n) for j in adjacency])\n\n return G","def increasing_cover_relations(self):\n relations = []\n size = self.size()\n for i in range(1, size):\n for j in range(i + 1, size + 1):\n if self.le(i, j):\n relations.append((i, j))\n break\n return relations","def generate_computational_graph(RHS, schema):\n computational_graph=dict()\n for level in range(3):\n #use brute force to generate candidates for each level\n computational_graph[level]=[]\n if level== 0:\n for attribute in schema:\n if attribute !=RHS:\n computational_graph[level].append(set([attribute]))\n\n else:\n for element1 in computational_graph[level-1]:\n for element2 in computational_graph[0]:\n newelement = element1.union(element2)\n if newelement not in computational_graph[level]:\n if len(newelement)==level+1:\n computational_graph[level].append(newelement)\n\n return computational_graph","def _anchored_successors(self, n):\n\n # loop on all outgoing edges\n for t in self.successors(n):\n \n # if neighbor is anchored\n # stop looking for (necessarily later) successors\n if t.anchored:\n yield t\n continue\n\n # if neighbor is not anchored\n # look one level deeper\n for tt in self._anchored_successors(t):\n yield tt","def cX(cb):\n allNodes = b.allNodes(group=cb)\n for n in allNodes:\n allNodes = allNodes + cX(n)\n\n return allNodes","def neato_cooccurrence_graph( nC, v, labels, max_nodes = 10, fnam_stem = \"test\", label_nodes_directly = False, scale=1.0, min_node_size = 0.1 ):\n \n nv = v.astype( float32 ) / v.max()\n\n cutoff = cooccur_cutoff( nC, max_nodes );\n\n graph = pydot.Dot( graph_type = 'graph' )\n graph.set_overlap(\"false\")\n coords = zip(*(nC >= cutoff).nonzero())\n\n # make a dict of all nodes which are mentioned in the coords\n nodes = {}\n index = 1\n for coord in set(chain.from_iterable(coords)) :\n if not nodes.has_key( coord ) :\n node = pydot.Node( str(coord) )\n if v != None :\n #print coord\n label = labels[coord]\n if label_nodes_directly :\n node.set_label( label )\n else :\n node.set_label( str(index) )\n #node.set_penwidth( nv[ coord ] )\n node.set_fixedsize(\"true\")\n node.set_width( max(min_node_size,scale *nv[ coord ]) )\n node.set_shape(\"circle\")\n nodes[ coord ] = node\n graph.add_node( node )\n index = index + 1\n\n for coord in coords :\n \n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\n edge.set_weight( nC[coord] )\n edge.set_penwidth( nC[coord]*5 )\n #edge.set_label( str(int(m[coord]) ))\n graph.add_edge(edge)\n\n if not label_nodes_directly : \n legend = pydot.Node( \"legend\" )\n nodelist = nodes.items()\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\n legend.set_label( \"\\l\".join([x[1].get_label()+\":\"+labels[x[0]] for x in nodelist])+\"\\l\" )\n legend.set_shape(\"box\")\n graph.add_node(legend)\n\n #print graph.to_string()\n graph.write_dot(fnam_stem+'.dot', prog='neato' )\n graph.write_png(fnam_stem+'.png', prog='neato' )\n #graph.write_pdf(fnam_stem+'.pdf', prog='neato' )","def connectCns(cnxDict, nsRig=None, nsSkin=None):\n for i, jnt in enumerate(cnxDict[\"joints\"]):\n if nsSkin:\n oJnt = pm.PyNode(nsSkin + \":\" + jnt)\n else:\n oJnt = pm.PyNode(jnt)\n\n if cnxDict[\"attrs\"][i][0]:\n if nsRig:\n oAttr = pm.PyNode(nsRig + \":\" + cnxDict[\"attrs\"][i][0])\n else:\n oAttr = pm.PyNode(cnxDict[\"attrs\"][i][0])\n\n oNode = oAttr.node()\n oTrans = pm.listConnections(\n pm.listConnections(oNode.inputMatrix)[0].matrixIn[0])\n pm.parentConstraint(oTrans, oJnt, mo=True)\n pm.scaleConstraint(oTrans, oJnt, mo=True)","def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\n for downstream_key in self.downstream_deps:\n relationship = GraphRelationship(\n start_key=self.column_key,\n start_label=ColumnMetadata.COLUMN_NODE_LABEL,\n end_label=ColumnMetadata.COLUMN_NODE_LABEL,\n end_key=downstream_key,\n type=ColumnLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\n reverse_type=ColumnLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\n attributes={}\n )\n yield relationship","def canonical_coloring_label_1(G,c):\n \n H = G.copy()\n #H.allow_loops( true )\n\n for i in c:\n print( i )\n H.add_edges([(i,j) for j in c[i]])\n\n P = [G.vertices(), c.keys()]\n return H.canonical_label(partition=P)","def calc_critical_paths(self):\n visited = set([])\n nodes = set(self.get_leaves())\n\n while nodes:\n n = nodes.pop()\n n.update_critical_path(n.latency())\n visited.add(n)\n cp = n.critical_path\n\n for p in n.parents:\n p.update_critical_path(cp + p.latency())\n # if p not in visited:\n nodes.add(p)\n # visited.add(p)\n\n for d in n.serial_parents:\n d.update_critical_path(cp + 1)\n # if d not in visited:\n nodes.add(d)\n # visited.add(d)","def compute_centrality_for_nodes(graph: nx.Graph):\n nodes_centralities = {}\n degree_centralities = nx.degree_centrality(graph)\n betweeness_centralities = nx.betweenness_centrality(graph, normalized=True)\n closeness_centralities = nx.closeness_centrality(graph)\n for node in graph.nodes:\n closeness = closeness_centralities[node]\n degree = degree_centralities[node]\n betweeness = betweeness_centralities[node]\n nodes_centralities[node] = {\n \"degree\": degree,\n \"closeness\": closeness,\n \"betweeness\": betweeness\n }\n\n return nodes_centralities","def graph():\n\n graph = {'A': ['B', 'C'],\n 'B': ['C', 'D'],\n 'C': ['D'],\n 'D': ['C'],\n 'E': ['F'],\n 'F': ['C']}\n\n def generate_edges(graph):\n \"\"\" Convert the dict representation of a graph into a list one\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\n \"\"\"\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges\n\n a = generate_edges(graph=graph)\n print(a)","def part1c_0():\n xs = exampleInput\n T = submission.computeEdgeMarginals(simpleCRF, xs)\n for t in T:\n grader.requireIsEqual( 1.0, sum(t.values()) )","def clusters_connected( self):\n def check_connected( k, vertices, edges):\n dads = {}\n for p in vertices:\n dads[p] = p\n\n def Find( c):\n while c != dads[c]:\n c = dads[c]\n return c\n\n def Union( p, q):\n dads[Find(p)] = Find(q)\n\n for p,q in edges:\n Union( p, q)\n\n stuff = set([ Find(p) for (k,p) in dads.items()])\n assert len(stuff) == 1, \"More than one partition\"\n\n vertices = collections.defaultdict( list)\n for p in itertools.product( range(self.n), repeat=2):\n vertices[self.raster[p]].append( p)\n\n def X():\n for x in range(self.n-1):\n for y in range(self.n):\n yield (x,y),(x+1,y)\n\n def Y():\n for x in range(self.n):\n for y in range(self.n-1):\n yield (x,y),(x,y+1)\n\n connections = collections.defaultdict( list)\n for (p,q) in itertools.chain( X(), Y()):\n if self.raster[p] == self.raster[q]:\n connections[self.raster[p]].append( ( p, q))\n\n for (k,v) in vertices.items():\n check_connected( k, v, connections[k])","def cocite(G,min_citations = 2):\n\n\n if not G.is_directed():\n msg = \"The cocitation algorithm requires a directed citation graph as an input.\"\n raise nx.NetworkXError(msg)\n\n #assert type(G) == nx.classes.digraph.DiGraph\n\n edges = {}\n #for each node\n for n in G.nodes():\n # for each outward edge (citing)\n out = G.out_edges(n)\n for i in out:\n for j in out:\n if i==j: break\n\n pair = tuple(set([i[1],j[1]]))\n try: edges[pair] = edges[pair] + 1\n except: edges[pair] = 1\n\n CC = G.to_undirected() # this returns a deepcopy\n CC = nx.create_empty_copy(CC, with_data=True)\n\n edgelist = [(i[0][0],i[0][1],i[1]) for i in edges.viewitems() if i[1]>min_citations]\n\n CC.add_weighted_edges_from(edgelist)\n\n return CC","def connected_components(graph):\n all_nodes = list(graph.keys())\n\n counter = 0\n explored = set()\n components = []\n for node in all_nodes:\n if node not in explored:\n counter += 1\n visited = bfs(graph, node)\n components.append(visited)\n explored = explored.union(visited)\n\n return explored, components, counter","def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\n for downstream_key in self.downstream_deps:\n relationship = GraphRelationship(\n start_key=self.table_key,\n start_label=TableMetadata.TABLE_NODE_LABEL,\n end_label=TableMetadata.TABLE_NODE_LABEL,\n end_key=downstream_key,\n type=TableLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\n reverse_type=TableLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\n attributes={}\n )\n yield relationship","def findDiscripancies(taxonomy):\n i = 0\n for entry in taxonomy:\n if entry['parentName'] != None:\n print entry['nodeName']\n if entry['nodeName'].lower() == entry['parentName'].lower():\n i += 1\n print \"No of same nodes = {} \" .format(i)","def likely_pairs(self, k=2):\n for a in self.G.nodes():\n if not self.eligible_node(a):\n continue\n for b in neighbourhood(self.G, a, k):\n if not self.eligible_node(b):\n continue\n yield (a, b)","def run_tests(g: Graph) -> None:\n print( g.nodes() , \"->\" , ', '.join([f\"{l}\" for l in g.scc()]) , f\"({g.cyclic()})\" )\n for n in g.nodes():\n for m in [m for m in g.nodes() if m != n]:\n p = g.path(n,m)\n if p is not None:\n assert p[0] == n\n assert p[-1] == m\n for i in range(1,len(p)):\n assert g.is_edge(p[i-1], p[i])\n print(\" \", n, \"->\", m, \":\", ' -> '.join([f\"{v}\" for v in p]))","def identify_coref_chains(dialog):\n\n for r_id, datum in enumerate(dialog['dialog']):\n label = datum['template']\n if label in gvars.METAINFO['independent_questions']:\n dialog['graph']['history'][r_id + 1]['dependence'] = None\n continue\n\n if (label == 'exist-attribute-group' or label == 'count-attribute-group' or\n label == 'count-all-group'):\n dialog['graph']['history'][r_id + 1]['dependence'] = r_id - 1\n continue\n\n if 'imm' in label:\n dialog['graph']['history'][r_id + 1]['dependence'] = r_id - 1\n continue\n\n if 'early' in label:\n # Go over previous history.\n cur_history = dialog['graph']['history'][r_id + 1]\n assert 'focus_id' in cur_history and 'focus_desc' in cur_history,\\\n 'More focus objects than one, no focus objects!'\n focus_id = cur_history['focus_id']\n for attr in gvars.METAINFO['attributes']:\n if attr in cur_history['focus_desc']: break\n\n history = dialog['graph']['history'][:r_id + 1]\n for hist_id, hist_datum in enumerate(history):\n for obj in hist_datum['objects']:\n if obj['id'] == focus_id and attr in obj:\n dialog['graph']['history'][r_id + 1]['dependence'] = hist_id - 1\n break\n return dialog","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def cross_transitivity_sparse(self, node_list1, node_list2):\n cross_degree = self.cross_degree(node_list1, node_list2)\n\n # Get sparse adjacency matrix\n A = self.sp_A[node_list1+node_list2, :][:, node_list1+node_list2]\n # Get subnetwork sizes\n N1, N2 = len(node_list1), len(node_list2)\n # Initialize\n cross_transitivity = 0.0\n # Set counter\n counter_triangles = 0.0\n counter_triples = 0.0\n # Calculate cross transitivity from subnetwork 1 to subnetwork 2\n # Loop over nodes in subnetwork 1\n for i in range(N1):\n node1 = i\n if cross_degree[i] > 1:\n # Loop over unique pairs of nodes in subnetwork 2\n for j in range(N1, N1+N2):\n node2 = j\n for k in range(N1, j):\n node3 = k\n if A[node1, node2] == 1 and A[node1, node3] == 1:\n counter_triples += 1\n if A[node2, node3] == 1:\n counter_triangles += 1\n\n if counter_triples:\n cross_transitivity = counter_triangles / counter_triples\n return cross_transitivity","def enumerate_links_around_node(self, node):\n\n l0 = self.node_link[node]\n l = l0\n edges = []\n traversing = True\n while traversing:\n edges.append(l)\n v = l[0]\n if v == node:\n l = self.pred_right[l]\n else:\n l = self.pred_left[l]\n if l0 == l:\n traversing = False\n if l0[1] == l[0] and l0[0] == l[1]:\n traversing = False\n #print v, l\n #raw_input('here')\n return edges","def generate_constraints_between_chains(self):\n node_to_chain_mapping = defaultdict(set)\n # collect all places where each node is used and at what subchain index\n for chain_idx in range(len(self.chains)):\n chain = self.chains[chain_idx]\n for subchain_idx in range(len(chain)):\n parent, child = chain[subchain_idx]\n node_to_chain_mapping[parent].add(\n AbstractConstraint(chain_idx, subchain_idx)\n )\n # don't forget about the final child in the chain (parents are already accounted for)\n final_parent, final_child = chain[-1]\n node_to_chain_mapping[final_child].add(\n AbstractConstraint(chain_idx, len(chain))\n )\n # our final mapping correlates constraints on a per-chain basis\n # e.g. for chain index 0 at subchain index 1, we have a constraint (shared node) in chain 2\n chain_constraints = list()\n for chain_idx in range(len(self.chains)):\n chain = self.chains[chain_idx]\n chain_constraint = [set() for i in range(len(chain) + 1)]\n for subchain_idx in range(len(chain)):\n parent, child = chain[subchain_idx]\n node_constraints = node_to_chain_mapping[parent]\n for constraint in node_constraints:\n if constraint.chain_index != chain_idx:\n chain_constraint[subchain_idx].add(constraint)\n # don't forget about the final child in the chain (parents are already accounted for)\n final_parent, final_child = chain[-1]\n node_constraints = node_to_chain_mapping[final_child]\n for constraint in node_constraints:\n if constraint.chain_index != chain_idx:\n chain_constraint[len(chain)].add(constraint)\n chain_constraints.append(chain_constraint)\n return chain_constraints","def get_relations(log):\n # finding loops of length two\n # ordering relations\n triangle = {}\n for trace in log:\n i = 0\n while i < len(trace) - 2:\n current = trace.__getitem__(i)\n successor = trace.__getitem__(i + 1)\n successor2 = trace.__getitem__(i + 2)\n if current == successor2:\n if current in triangle:\n triangle[current].append(successor)\n else:\n triangle[current] = [successor]\n i += 1\n for key, value in triangle.items():\n triangle[key] = set(value)\n square = {}\n for key in triangle:\n for element in triangle[key]:\n if element in triangle:\n if key in triangle[element]:\n if key in square and element in square:\n square[key].append(element)\n square[element].append(key)\n elif key in square and element not in square:\n square[key].append(element)\n square[element] = [key]\n elif key not in square and element in square:\n square[key] = [element]\n square[element].append(key)\n else:\n square[key] = [element]\n square[element] = [key]\n for key, value in square.items():\n square[key] = set(value)\n # ordering relation following\n follows = {}\n for trace in log:\n i = 0\n while i < len(trace) - 1:\n current = trace.__getitem__(i)\n successor = trace.__getitem__(i + 1)\n if current in follows:\n if successor not in follows[current]:\n follows[current].append(successor)\n else:\n follows[current] = [successor]\n i += 1\n # transforming list to set\n for key, value in follows.items():\n follows[key] = set(value)\n # ordering relation causal\n causal = {}\n if len(square) != 0:\n for key in follows:\n for element in follows[key]:\n if element in follows:\n if key in square:\n if (not (key in follows[element])) or (element in square[key]):\n if key in causal:\n causal[key].append(element)\n else:\n causal[key] = [element]\n else:\n if (not (key in follows[element])):\n if key in causal:\n causal[key].append(element)\n else:\n causal[key] = [element]\n else:\n if key in causal:\n causal[key].append(element)\n else:\n causal[key] = [element]\n else:\n for key in follows:\n for element in follows[key]:\n if element in follows:\n if (not (key in follows[element])):\n if key in causal:\n causal[key].append(element)\n else:\n causal[key] = [element]\n else:\n if key in causal:\n causal[key].append(element)\n else:\n causal[key] = [element]\n\n for key, value in causal.items():\n causal[key] = set(value)\n # ordering relation unrelated if no other ordering is applied\n # ordering relation parallel\n parallel = {}\n if len(square) != 0:\n for key in follows:\n for element in follows[key]:\n if element in follows:\n if key in follows[element]:\n if element in follows[key]:\n if key in square:\n if not element in square[key]:\n if key in parallel:\n parallel[key].append(element)\n else:\n parallel[key] = [element]\n else:\n if key in parallel:\n parallel[key].append(element)\n else:\n parallel[key] = [element]\n\n else:\n for key in follows:\n for element in follows[key]:\n if element in follows:\n if key in follows[element]:\n if element in follows[key]:\n if key in parallel:\n parallel[key].append(element)\n else:\n parallel[key] = [element]\n\n for key, value in parallel.items():\n parallel[key] = set(value)\n return causal, parallel, follows","def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)","def __CI_helper(self, inh):\r\n list_of_ci_relation = list()\r\n if inh is None:\r\n logger.info(\"There are no CI relations\")\r\n else:\r\n for parent_and_child in inh:\r\n parent = parent_and_child.attrib.get(\"ci\")\r\n child = parent_and_child.attrib.get(\"cj\")\r\n for inner_parent_and_child in inh:\r\n inner_parent = inner_parent_and_child.attrib.get(\"ci\")\r\n inner_child = inner_parent_and_child.attrib.get(\"cj\")\r\n if inner_parent == parent and inner_child != child:\r\n ci_tuple = (parent, child, inner_child)\r\n list_of_ci_relation.append(ci_tuple)\r\n logger.debug(\"Found CI: (%s, %s, %s)\" % (ci_tuple[0], ci_tuple[1], ci_tuple[2]))\r\n list_of_ci_relation = list(dict.fromkeys(list_of_ci_relation))\r\n index = 0\r\n while True:\r\n if index == len(list_of_ci_relation):\r\n break\r\n for ci in list_of_ci_relation:\r\n if index == len(list_of_ci_relation):\r\n break\r\n if list_of_ci_relation[index] == ci:\r\n continue\r\n # check if both parents are the same (index zero in tuple is for parent)\r\n if ci[0] == list_of_ci_relation[index][0]:\r\n if sorted(ci) == sorted(list_of_ci_relation[index]):\r\n del list_of_ci_relation[index]\r\n index = 0\r\n index = index + 1\r\n return list_of_ci_relation","def MatchRelationshipConfrontation(C):\n for c in C:\n if c.relationships is None:\n continue\n for i, longname in enumerate(c.relationships):\n found = False\n for cor in C:\n if longname.lower() == cor.longname.lower():\n c.relationships[i] = cor\n found = True\n return C","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def test_2():\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_2).construct_hierarchy()\n asc = h.atom_selection_cache()\n ncs_inp = iotbx.ncs.input(\n hierarchy=h,\n params=ncs_pars.ncs_search)\n ncs_groups = ncs_inp.get_ncs_restraints_group_list()\n assert len(ncs_groups) == 1\n # group 1\n assert ncs_groups[0].master_iselection.all_eq(\n asc.selection(string = \"chain A\").iselection())\n g1_c = ncs_groups[0].copies\n assert len(g1_c)==1\n assert g1_c[0].iselection.all_eq(\n asc.selection(string = \"chain B\").iselection())","def connectivity_matrix(self):\n # TODO: make this more memory efficient by ordering i,j in code when needed.\n temp = []\n for i in range(self.n_atom):\n for j in range(i+1, self.n_atom):\n if self.bond(i, j):\n temp.append([i+1, j+1])\n self.connect = np.asarray(temp)","def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v","def test_is_strongly_connected(self):\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\n assert_true(is_strongly_connected(G))","def get_all_arcs(self):\n return [ (i, j) for i in self.constraints for j in self.constraints[i] ]","def cousin(self, a, b):\n a_node = self.names_to_nodes[a]\n b_node = self.names_to_nodes[b]\n \n def build_branch(node):\n branch = [node]\n parent = node.get_parent()\n while parent != None:\n branch.append(parent)\n parent = parent.get_parent()\n return branch\n \n a_branch = build_branch(self.names_to_nodes[a])\n b_branch = build_branch(self.names_to_nodes[b])\n \n def branch_distance(a_node, b_node):\n a_distance = 0\n b_distance = 0\n a_parent = a_node.get_parent()\n b_parent = b_node.get_parent()\n if a_parent == None:\n return a_distance\n if b_parent == None:\n return b_distance\n while a_parent not in b_branch and a_parent != None:\n a_distance += 1\n a_parent = a_parent.get_parent()\n while b_parent not in a_branch and b_parent != None:\n b_distance += 1 \n b_parent = b_parent.get_parent()\n cousin_tuple = (min(a_distance, b_distance), abs(a_distance - b_distance))\n return cousin_tuple \n \n for m_a in a_branch:\n if m_a == b_node:\n return (-1,0)\n for m_b in b_branch:\n if m_b == a_node:\n return (-1,0)\n if self.names_to_nodes[a] == self.names_to_nodes[b]:\n return (-1, 0)\n else:\n return branch_distance(a_node, b_node)","def coherence(self, network):\n\n # Initialise coherence\n coherence = 0\n\n for edge in list(network.edges(data='constraint')):\n if edge[2] == 'positive':\n if network.nodes[edge[0]]['truth_value'] == \\\n network.nodes[edge[1]]['truth_value']:\n coherence += 1\n else:\n coherence -= 1\n elif edge[2] == 'negative':\n if network.nodes[edge[0]]['truth_value'] == \\\n network.nodes[edge[1]]['truth_value']:\n coherence -= 1\n else:\n coherence += 1\n\n return coherence","def compute_cpts_network(df, network):\n P = dict()\n for idx, pair in enumerate(network):\n if pair.parents is None:\n cpt = CPT.from_factor(Factor.from_data(df, cols=[pair.node])).normalize()\n # cpt = CPT(marginal_distribution, conditioned=[pair.node]).normalize()\n else:\n # todo: there should be a from_data at CPT\n cpt = CPT.from_factor(Factor.from_data(df, cols=[*pair.parents, pair.node])).normalize()\n # cpt = CPT(joint_distribution, conditioned=[pair.node]).normalize()\n\n # add conditional distribution to collection\n P[pair.node] = cpt\n return P","def get_connected_nodes(self, node):\n assert node in self.nodes, \"No node \"+str(node)+\" in graph \"+str(self)\n result = [x.node2 for x in self.edges if x.node1 == node]\n result += [x.node1 for x in self.edges if x.node2 == node]\n return sorted(result)","def circulant_gen(min_order, max_order):\n\n for num_vertices in range(min_order, max_order + 1):\n all_j_values = [x for x in range(1, floor(num_vertices / 2.0))]\n j_values_iter = powerset(all_j_values)\n\n # for every possible offset combination\n for j_value_set in j_values_iter:\n # get the adjacency matrix of the circulant graph\n adj = circulant_adj(j_value_set, num_vertices)\n G = nx.from_numpy_matrix(adj)\n\n if G.size() > 0 and nx.is_connected(G):\n yield (G, name_circulant(num_vertices, j_value_set))","def nsi_cross_closeness_centrality(self, node_list1, node_list2):\n shortest_paths = self.path_lengths()\n node_weights = self.node_weights\n\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\n\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\n W = sum(node_weights[node_list2])\n return W / np.dot(nsi_cross_paths, node_weights[node_list2])","def test_acyclic_chains():\n names = ['robot', 'box1', 'box2']\n chains = lambda: FactoredRandomGeometricGraph.acyclic_chains(names)\n\n expected_number = 16\n actual_number = sum(1 for _ in chains())\n assert actual_number == expected_number, \\\n \"Expected {} chains; actual value was {}\".format(\n expected_number, actual_number)\n\n assert all(\n FactoredRandomGeometricGraph.is_acyclic(chain)\n for chain in chains())","def complex_network_mapping(graph):\n vect = []\n\n n = nx.number_of_nodes(graph)\n e = nx.number_of_edges(graph)\n print n, e\n\n# adj = nx.adjacency_matrix(graph).toarray()\n# adj_bin = np.where(adj > 0, 1., 0.)\n# adj_conn = 1 - adj\n adj_bin = nx.adjacency_matrix(graph).toarray()\n adj_bin = np.array(adj_bin, dtype=np.float)\n\n # Node Betweenness binary\n bt_bin = nx.betweenness_centrality(graph).values()\n avg_btb = np.mean(bt_bin)\n vect.append(avg_btb)\n\n # Edge betweenness\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\n vect.append(np.mean(ebt))\n\n # Eigen vector centrality binary\n evc_bin = eigenvector_centrality_und(adj_bin)\n avg_evcb = np.mean(evc_bin)\n vect.append(avg_evcb)\n\n # Flow coefficient\n _, flow_bin, _ = flow_coef_bd(adj_bin)\n avg_flow = np.mean(flow_bin)\n vect.append(avg_flow)\n\n # Kcoreness centrality\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\n avg_kcor = np.mean(kcor_bin)\n vect.append(avg_kcor)\n\n # Degree assortivity\n dac = nx.degree_assortativity_coefficient(graph)\n vect.append(dac)\n\n # Page rank centrality\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\n# avg_pgr = np.mean(pgr_wei)\n# vect.append(avg_pgr)\n\n # Rich club coefficient\n# rcc = nx.rich_club_coefficient(graph).values()\n# avg_rcc = np.mean(rcc)\n# vect.append(avg_rcc)\n\n # Transitivity\n tr = nx.transitivity(graph)\n vect.append(tr)\n\n # average clustering\n avg_clst = nx.average_clustering(graph)\n vect.append(avg_clst)\n\n glb_ef = efficiency_bin(adj_bin)\n vect.append(glb_ef)\n\n return vect","def get_dependency_subgraphs(graph, node_attrib='label', edge_attrib='label'):\n assert nx.is_directed_acyclic_graph(graph)\n for n in xrange(graph.number_of_nodes()):\n for subnodes in itertools.combinations(graph.nodes(), n+1):\n subgraph_candidate = graph.subgraph(subnodes)\n if is_dependency_subgraph(graph, subgraph_candidate,\n node_attrib=node_attrib,\n edge_attrib=edge_attrib):\n yield subgraph_candidate","def msep_from_given(self, A, C=set()):\n\n A = core_utils.to_set(A)\n C = core_utils.to_set(C)\n\n determined = set()\n descendants = set()\n\n for c in C:\n determined.add(c)\n descendants.add(c)\n self._add_upstream(descendants, c)\n\n reachable = set()\n i_links = set()\n labeled_links = set()\n\n for a in A:\n i_links.add((None, a))\n reachable.add(a)\n\n while True:\n i_p_1_links = set()\n # Find all unlabled links v->w adjacent to at least one link u->v labeled i, such that (u->v,v->w) is a legal pair.\n for link in i_links:\n u, v = link\n for w in self._adjacent[v]:\n if not u == w and (v, w) not in labeled_links:\n if self._is_collider(u, v, w): # Is collider?\n if v in descendants:\n i_p_1_links.add((v, w))\n reachable.add(w)\n else: # Not collider\n if v not in determined:\n i_p_1_links.add((v, w))\n reachable.add(w)\n\n if len(i_p_1_links) == 0:\n break\n\n labeled_links = labeled_links.union(i_links)\n i_links = i_p_1_links\n\n return self._nodes.difference(A).difference(C).difference(reachable)","def calc_process_cohesion(partitions, graph):\n ch = 0\n for part in partitions:\n crc = calc_community_relation_cohesion(part, graph)\n cic = calc_community_information_cohesion(part, graph)\n ch = ch + (crc * cic)\n ch = ch / len(partitions)\n return ch","def connections(self, src=False, dst=True, params=True): \n conns = []\n if params:\n if src:\n #grab the node params that this node is a src to\n edges = self.parent.graph.out_edges(self, data=True) \n conns.extend([ edge[2][\"dst_param\"] for edge in edges ])\n if dst:\n #grab the node param that this node is a dst to\n edges = self.parent.graph.in_edges(self, data=True) \n conns.extend([ edge[2][\"src_param\"] for edge in edges ])\n else: \n if src:\n conns.extend(self.parent.graph.successors(self))\n if dst:\n conns.extend(self.parent.graph.predecessors(self))\n \n return conns","def connect_all(graph, nodeset):\n for element in nodeset:\n graph.add_node(element)\n for element1 in nodeset:\n for element2 in nodeset:\n if not element1 == element2:\n graph.add_edge(element1, element2)\n return graph","def reactions(self):\n for node in self.graph:\n if not isinstance(node, Molecule):\n yield node","def contract(self, cycle):\n # create a new id to represent the cycle in the resulting graph.\n new_id = Digraph.new_node_id\n Digraph.new_node_id += 1\n\n # we store links that cross into and out of the cycle in these maps. the\n # to_cycle map contains links reaching into the cycle, and is thus a map\n # from each target node in the cycle to a list of source nodes that\n # reach that target from outside the cycle. the from_cycle map contains\n # links going out from the cycle, and is thus a map from each source\n # node in the cycle to a list of target nodes outside the cycle.\n to_cycle = collections.defaultdict(list)\n from_cycle = collections.defaultdict(list)\n\n scores = {}\n labels = {}\n succs = collections.defaultdict(list)\n for source, target in self.iteredges():\n if source in cycle:\n if target not in cycle:\n from_cycle[target].append(source)\n elif target in cycle:\n # we know source is not in cycle from above.\n to_cycle[source].append(target)\n else:\n succs[source].append(target)\n succs[target]\n scores[source, target] = self.get_score(source, target)\n labels[source, target] = self.get_label(source, target)\n\n old_edges = collections.defaultdict(list)\n\n # for each target in our graph that's reachable from the cycle, add an\n # edge from our new node to that target, with an appropriate score.\n for target, sources in from_cycle.items():\n succs[new_id].append(target)\n max_score = -1e100\n max_source = None\n for s in sources:\n score = self.get_score(s, target)\n if score > max_score:\n max_score = score\n max_source = s\n old_edges[max_source].append(target)\n scores[new_id, target] = max_score\n labels[new_id, target] = self.get_label(max_source, target)\n\n # before we handle the to_cycle map, we need to build some convenience\n # information for the cycle -- total score, and predecessor edges.\n pred = {}\n cycle_score = 0\n for s, t in cycle.iteredges():\n pred[t] = s\n cycle_score += self.get_score(s, t)\n\n # for each source in our graph that reaches into the cycle, add an edge\n # from the source to our new node, with an appropriate edge score.\n for source, targets in to_cycle.items():\n succs[source].append(new_id)\n max_score = -1e100\n max_target = None\n for t in targets:\n score = self.get_score(source, t) - self.get_score(pred[t], t)\n if score > max_score:\n max_score = score\n max_target = t\n old_edges[source].append(max_target)\n scores[source, new_id] = cycle_score + max_score\n labels[source, new_id] = self.get_label(source, max_target)\n\n return (\n new_id,\n old_edges,\n Digraph(\n succs, lambda s, t: scores[s, t], lambda s, t: labels[s, t]\n ),\n )","def _initializeAdjacencyList(self):\n\n if self.comm.rank == 0:\n # First, create a dictionary of common edges shared by components\n edgeToFace = {}\n for elemID in self.bdfInfo.elements:\n elemInfo = self.bdfInfo.elements[elemID]\n elemConn = elemInfo.nodes\n compID = self.meshLoader.nastranToTACSCompIDDict[elemInfo.pid]\n nnodes = len(elemConn)\n if nnodes >= 2:\n for j in range(nnodes):\n nodeID1 = elemConn[j]\n nodeID2 = elemConn[(j + 1) % nnodes]\n\n if nodeID1 < nodeID2:\n key = (nodeID1, nodeID2)\n else:\n key = (nodeID2, nodeID1)\n\n if key not in edgeToFace:\n edgeToFace[key] = [compID]\n elif compID not in edgeToFace[key]:\n edgeToFace[key].append(compID)\n\n # Now we loop back over each element and each edge. By\n # using the edgeToFace dictionary, we can now determine\n # which components IDs (jComp) are connected to the\n # current component ID (iComp).\n self.adjacentComps = []\n\n for edgeKey in edgeToFace:\n if len(edgeToFace[edgeKey]) >= 2:\n for i, iComp in enumerate(edgeToFace[edgeKey][:-1]):\n for jComp in edgeToFace[edgeKey][i + 1 :]:\n if iComp < jComp:\n dvKey = (iComp, jComp)\n else:\n dvKey = (jComp, iComp)\n if dvKey not in self.adjacentComps:\n self.adjacentComps.append(dvKey)\n\n else:\n self.adjacentComps = None\n\n # Wait for root\n self.comm.barrier()","def perms_are_connected(g, n):\n from sage.graphs.graph import Graph\n G = Graph()\n if g:\n G.add_vertices(g[0].domain())\n for p in g:\n G.add_edges(p.dict().items())\n return G.is_connected()","def iter_node(self,i):\n nd = self.nodes[i]\n for kn in nd.get_close():\n # for kn in nd.get_known():\n # for kn in nd.neighbours:\n kn_node = self.nodes[kn.lindex]\n nd.add_known_nodes(kn.path_len,kn_node.get_close())","def iter_nodes(self):","def cluster_connectivity(G, weight='weight'):\n\t# 1) indexing the edges by community\n\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\n\tfor node1, node2 in G.edges():\n\t\tcomm1 = G.nodes[node1]['community']\n\t\tcomm2 = G.nodes[node2]['community']\n\t\tif comm2 not in sum_edges_dic[comm1]:\n\t\t\tsum_edges_dic[comm1][comm2] = 0\n\t\t\tsum_edges_dic[comm2][comm1] = 0\n\t\telse:\n\t\t\tif weight is None:\n\t\t\t\tsum_edges_dic[comm1][comm2] += 1\n\t\t\t\tsum_edges_dic[comm2][comm1] += 1\n\t\t\telse:\t\n\t\t\t\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\n\t\t\t\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\n\tc_connectivity = {}\n\t# 2) computing the connectivity\n\tfor com in sum_edges_dic:\n\t\tin_out_edges = sum(sum_edges_dic[com].values())\n\t\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \n\treturn c_connectivity","def scc(self):\n return self.to_ddm().scc()","def decreasing_cover_relations(self):\n relations = []\n for i in range(self.size(), 1, -1):\n for j in range(i - 1, 0, -1):\n if self.le(i, j):\n relations.append((i, j))\n break\n return relations","def respect_matching(self, network):\n\n # Iterate over the connected components of the network\n\n for component in nx.connected_component_subgraphs(network):\n\n # If the component has only two nodes it is respected by default\n\n if component.number_of_nodes() < 3:\n continue\n\n # Partition the nodes into biparite sets\n\n left, right = nx.bipartite.sets(component)\n\n # As a convention, the left side is the one with fewer vertices.\n # Swap left and right if right has fewer vertices.\n\n if len(left) > len(right):\n left, right = right, left\n\n # The way we encode the constraint that a maximum cardinality\n # matching of the symmetrization graph be respected is to force\n # one edge incident to each vertex on the left side of each\n # component be activated, while at most one edge incident to each\n # vertex of the right side be activated. This will activate a\n # maximum cardinality matching of the graph IFF the size of the\n # maximum cardinality matching of each component is the number of\n # vertices in the smaller biparite set of that component. Here we\n # run a check to verify that this is the case.\n\n mcm_size = len(nx.max_weight_matching(component,\n maxcardinality=True))\n\n assert mcm_size == len(left)\n\n # Iterate over vertices on the smaller biparite set and force\n # exactly one of their incident edges to be activated\n\n for l in left:\n table = self.activation_variables[l]\n lits = [table[r] for r in table]\n self.at_most_one(lits)\n self.add_clause(lits)\n\n # Iterate over vertices on the larger bipartite set and force\n # at most one of their incident edges to be activated\n\n for r in right:\n table = self.activation_variables[r]\n lits = [table[l] for l in table]\n self.at_most_one(lits)","def iter_clusters(letter_iter):\n consonants = []\n for letter in letter_iter:\n if letter.is_vowell():\n if consonants:\n yield tuple(consonants)\n consonants = []\n yield tuple([letter])\n else:\n consonants.append(letter)\n if consonants:\n yield tuple(consonants)","def extract_constraints(self, graphs):\n for g in graphs:\n fasta_id = g.graph['id']\n gc_content = self._compute_gc_content(g)\n cseq = self._extract_sequence_constraints(g,\n self.importance_threshold_sequence_constraint,\n self.min_size_connected_component_sequence_constraint)\n struct = self. _extract_structure_constraints(g,\n self.importance_threshold_structure_constraint,\n self.min_size_connected_component_structure_constraint,\n self.min_size_connected_component_unpaired_structure_constraint)\n\n yield struct, cseq, gc_content, fasta_id"],"string":"[\n \"def get_successors(self, node):\\n succs = []\\n parent_state = self.node_to_state(node)\\n for it in self.children:\\n child_node = (node[0] + it[0], node[1] + it[1])\\n child_state = self.node_to_state(child_node)\\n edge = self.interpolate(parent_state, child_state, self.distance_bw_states(parent_state, child_state)/self.path_resolution)\\n succs.append([child_node, edge])\\n return succs\",\n \"def cohen_sadeh(prelations):\\n # Adaptation to avoid multiple end nodes\\n successors = graph.reversed_prelation_table(prelations)\\n end_act = graph.ending_activities(successors)\\n\\n #Step 1. Construct work table with Immediate Predecessors\\n Columns = namedlist.namedlist('Columns', ['pre', 'blocked', 'dummy', 'suc', 'start_node', 'end_node'])\\n # [0 Predecesors, 1 Blocked, 2 Dummy, 3 Successors, 4 Start node, 5 End node]\\n # Blocked = (False or Activity with same precedents)\\n work_table = {}\\n for act, predecessors in prelations.items():\\n work_table[act] = Columns(set(predecessors), False, False, None, None, None)\\n\\n# print \\\"\\\\n--- Step 1 ---\\\"\\n# __print_work_table(work_table)\\n\\n #Step 2. Identify Identical Precedence Constraint of Diferent Activities\\n visited_pred = {}\\n for act, columns in work_table.items():\\n pred = frozenset(columns.pre)\\n if pred not in visited_pred:\\n visited_pred[pred] = act\\n else:\\n columns.blocked = visited_pred[pred]\\n\\n# print \\\"\\\\n--- Step 2 ---\\\"\\n# __print_work_table(work_table)\\n\\n\\n #Step 3. Identify Necessary Dummy Arcs\\n dups = set()\\n visited_act = set()\\n for columns in work_table.values():\\n if not columns.blocked:\\n for act in columns.pre:\\n if act in visited_act:\\n dups.add(act)\\n visited_act.add(act)\\n\\n# print \\\"\\\\n--- Step 3.1 ---\\\"\\n# print dups\\n\\n\\n #Step 3.2, 3.3 and 4. Create rows and information for Dummy Arcs\\n dummy_counter = collections.Counter()\\n for _, columns in work_table.items():\\n # Avoid blocked\\n if not columns.blocked:\\n predecessors = columns.pre\\n if len(predecessors) > 1:\\n for pre in list(predecessors):\\n if pre in dups:\\n predecessors.remove(pre)\\n dummy_name = pre + '-d' + str(dummy_counter[pre])\\n dummy_counter[pre] += 1\\n predecessors.add(dummy_name)\\n work_table[dummy_name] = Columns(set([pre]), False, True, None, None, None)\\n\\n# print \\\"\\\\n--- Step 4 ---\\\"\\n# __print_work_table(work_table)\\n\\n\\n #Step 5. Creating nodes\\n node = 0 # instead of 0, can start at 100 to avoid confusion with activities named with numbers when debugging\\n for act, columns in work_table.items():\\n if not columns.dummy and not columns.blocked:\\n columns.start_node = node\\n node += 1\\n\\n# print \\\"\\\\n--- Step 5a ---\\\"\\n# __print_work_table(work_table)\\n\\n for act, columns in work_table.items():\\n if not columns.dummy and columns.blocked:\\n columns.start_node = work_table[columns.blocked].start_node\\n\\n# print \\\"\\\\n--- Step 5b ---\\\"\\n# __print_work_table(work_table)\\n\\n\\n #Step 6. Associate activities with their end nodes\\n # (a) find one non-dummy successor for each activity\\n for act, columns in work_table.items():\\n for suc, suc_columns in work_table.items():\\n if not suc_columns.dummy and not suc_columns.blocked:\\n if act in suc_columns.pre:\\n columns.suc = suc\\n break\\n\\n# print \\\"\\\\n--- Step 6a ---\\\"\\n# __print_work_table(work_table)\\n\\n # (b) find end nodes\\n graph_end_node = node # Reserve one node for graph end \\n node += 1\\n for act, columns in work_table.items():\\n suc = columns.suc\\n if suc:\\n columns.end_node = work_table[suc].start_node\\n else:\\n # Create needed end nodes, avoiding multiple graph end nodes (adaptation)\\n if act in end_act:\\n columns.end_node = graph_end_node\\n else:\\n columns.end_node = node \\n node += 1\\n\\n# print \\\"\\\\n--- Step 6b ---\\\"\\n# __print_work_table(work_table)\\n\\n\\n #Step 7. Associate dummy arcs with start nodes\\n for act, columns in work_table.items():\\n if columns.dummy:\\n pred = iter(columns.pre).next()\\n start_node = work_table[pred].end_node\\n columns.start_node = start_node\\n\\n# print \\\"\\\\n--- Step 7 ---\\\"\\n# __print_work_table(work_table)\\n\\n\\n #Step 8. Generate the graph\\n pm_graph = pert.PertMultigraph()\\n for act, columns in work_table.items():\\n _, _, dummy, _, start, end = columns\\n pm_graph.add_arc((start, end), (act, dummy))\\n\\n p_graph = pm_graph.to_directed_graph()\\n return p_graph.renumerar()\",\n \"def calc_cc(graph):\\n\\tclustering_coeffs = {}\\n\\tfor node in graph.nodes():\\n\\t\\tclustering_coeffs[node] = { \\\"cc\\\" : nx.clustering(graph, node)}\\n\\tnx.set_node_attributes(graph, clustering_coeffs)\",\n \"def cc_visited(ugraph):\\n remain = set(ugraph.keys())\\n conn_comp = []\\n while remain:\\n node = remain.pop()\\n visited = bfs_visited(ugraph, node)\\n conn_comp.append(visited)\\n remain = remain.difference(visited)\\n return conn_comp\",\n \"def cc_visited(ugraph):\\r\\n\\tremaining_node = ugraph.keys()\\t\\t#The keys are accessible directly.\\r\\n\\t\\r\\n\\tcon_com = [] #connected component\\r\\n\\twhile len(remaining_node) != 0 :\\r\\n\\t\\tnode = random.choice(remaining_node)\\r\\n\\t\\tvisited = bfs_visited(ugraph,node)\\r\\n\\t\\tcon_com.append(visited)\\r\\n\\t\\tfor item in visited:\\r\\n\\t\\t\\tremaining_node.remove(item)\\r\\n\\treturn con_com\",\n \"def iteredges(self):\\n for source, targets in self.successors.items():\\n for target in targets:\\n yield source, target\",\n \"def cooccuranceBlock(ntupleSet,nodeList):\\n nodesPerNode = dict(zip(nodeList,[[] for n in range(len(nodeList))]))\\n for ntuple in ntupleSet:\\n for nodeInTuple in ntuple:\\n nodesPerNode[nodeInTuple].extend(ntuple)\\n \\n for a,v in nodesPerNode.iteritems():\\n differentNodes = set(v).difference(set([a]))\\n NumberdifferentNodes = len(differentNodes) \\n nodesPerNode[a] = (NumberdifferentNodes,differentNodes)\\n \\n return sorted(nodesPerNode.iteritems(),key=operator.itemgetter(1))\",\n \"def cc_visited(ugraph):\\n \\n remaining = set(ugraph.keys())\\n ccomp = []\\n while len(remaining) > 0:\\n node = remaining.pop()\\n visited = bfs_visited(ugraph,node)\\n ccomp.append(visited)\\n remaining.difference_update(visited)\\n \\n return ccomp\",\n \"def betweenness_centrality(self, node):\\n l=[]\\n b=0\\n for i in vertices:\\n if i!=node:\\n l.append(i)\\n comb=list(itertools.combinations(l,2))\\n \\n for c in comb:\\n count=0\\n l=self.all_shortest_paths(c[0],c[1])\\n if l==None:\\n print(c)\\n for i in range(len(l)):\\n if node in l[i]:\\n count+=1\\n b+=count/len(l)\\n\\n return b\",\n \"def connectivity_graph(rdm):\\n rdm = _rd_chem.AddHs(rdm)\\n atms = rdm.GetAtoms()\\n bnds = rdm.GetBonds()\\n asbs = dict(enumerate((rda.GetSymbol(), 0, None) for rda in atms))\\n cnns = {frozenset([rdb.GetBeginAtomIdx(), rdb.GetEndAtomIdx()]): (1, None)\\n for rdb in bnds}\\n return (asbs, cnns)\",\n \"def associate_successors(graph, node=\\\"\\\"):\\n return {\\n \\\"successors\\\": [\\n {\\n \\\"source\\\": node,\\n \\\"target\\\": succ,\\n \\\"edge_attribute\\\": graph.succ[node][succ][\\\"edge_attribute\\\"],\\n }\\n for succ in graph.succ[node]\\n ]\\n }\",\n \"def test_cc_visited(self):\\n graph1 = {0: set()}\\n self.assertEqual(p.cc_visited(graph1), [set([0])])\\n\\n graph2 = {0: set([1]), 1: set([0])}\\n self.assertEqual(p.cc_visited(graph2), [set([0,1])])\\n\\n graph3 = {0: set([]), 1: set([])}\\n self.assertItemsEqual(p.cc_visited(graph3), [set([0]), set([1])])\\n\\n graph4 = {0: set([]), 1: set([2]), 2: set([1])}\\n self.assertItemsEqual(p.cc_visited(graph4), [set([0]), set([1,2])])\\n\\n graph6 = {\\\"a\\\": set([]), \\\"b\\\": set([\\\"c\\\"]), \\\"c\\\": set([\\\"d\\\",\\\"b\\\"]), \\\"d\\\":set([\\\"e\\\", \\\"c\\\"]), \\\"e\\\":set([\\\"d\\\"]) }\\n self.assertItemsEqual(p.cc_visited(graph6), [set([\\\"a\\\"]), set([\\\"b\\\",\\\"c\\\", \\\"d\\\", \\\"e\\\"])])\",\n \"def _iter_pairs(graph):\\n for u, v in set(graph.edges_iter()):\\n yield u, v\",\n \"def transitive_closure(self, term_id_list):\\n\\n edges = set()\\n visited = set(term_id_list)\\n\\n for term_id in term_id_list:\\n current_term = term_id\\n\\n while current_term != 'KEGG Pathway':\\n next_term = self.term2parent[current_term]\\n edges.add((current_term, 'is_a', next_term))\\n visited.add(current_term)\\n current_term = next_term\\n\\n return visited, edges\",\n \"def condensation(G):\\n scc = strongly_connected_components(G)\\n mapping = dict([(n,tuple(sorted(c))) for c in scc for n in c])\\n cG = nx.DiGraph()\\n for u in mapping:\\n cG.add_node(mapping[u])\\n for _,v,d in G.edges_iter(u, data=True):\\n if v not in mapping[u]:\\n cG.add_edge(mapping[u], mapping[v])\\n return cG\",\n \"def strongly_connected_components(self):\\n for node in self.graph:\\n node.data.visited = False\\n\\n reverse_graph = self.reverse_graph()\\n dfs_reverse_graph = DFS(reverse_graph.graph, generate_stack=True)\\n dfs_reverse_graph.search()\\n\\n dfs_graph = DFS(self.graph, generate_scc=True)\\n\\n while dfs_reverse_graph.stack:\\n node = self.graph.get_node(dfs_reverse_graph.stack.top_pop())\\n if not node.data.visited:\\n dfs_graph.strongly_connected_components.append([])\\n dfs_graph.num_scc += 1\\n dfs_graph.explore(node)\\n return dfs_graph.num_scc, dfs_graph.strongly_connected_components\",\n \"def combinations(graph, all_combs, all_costs, all_values, start, prev_cost, prev_value, prev_nodes):\\n for ii in range(start, graph.size):\\n # combination\\n nodes = prev_nodes + [ii]\\n all_combs.append(nodes)\\n # cost\\n cost = prev_cost + graph.node_weights[ii][0]\\n all_costs.append(cost)\\n # value\\n value = prev_value + graph.node_weights[ii][1] - graph.node_weights[ii][0]\\n for node in prev_nodes: # complementarity\\n for adjacent in graph.graph[node]:\\n if adjacent[0] == ii:\\n value += adjacent[1]\\n all_values.append(value)\\n # recurse\\n combinations(graph, all_combs, all_costs, all_values, ii+1, cost, value, nodes)\",\n \"def ClusteringTransitivity(graph):\\n transitivity = nx.transitivity(graph)\\n return transitivity\",\n \"def coarsen(A, levels, self_connections=False):\\n # Function written by M. Defferrard, taken (almost) verbatim, from \\n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L5\\n graphs, parents = metis(A, levels)\\n perms = compute_perm(parents)\\n\\n for i, A in enumerate(graphs):\\n M, M = A.shape\\n\\n if not self_connections:\\n A = A.tocoo()\\n A.setdiag(0)\\n\\n if i < levels:\\n A = perm_adjacency(A, perms[i])\\n\\n A = A.tocsr()\\n A.eliminate_zeros()\\n graphs[i] = A\\n\\n# Mnew, Mnew = A.shape\\n# print('Layer {0}: M_{0} = |V| = {1} nodes ({2} added),'\\n# '|E| = {3} edges'.format(i, Mnew, Mnew-M, A.nnz//2))\\n\\n\\n return graphs, perms[0] if levels > 0 else None\",\n \"def pair_has_contradiction(graph, u, v):\\n relations = get_all_relations(graph, u, v)\\n return relation_set_has_contradictions(relations)\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def iterate_connected_atoms(self, atom):\\n successors_iter = self._execution_graph.successors_iter\\n return _depth_first_iterate(\\n self._execution_graph, {\\n co.FLOW: successors_iter,\\n co.TASK: successors_iter,\\n co.RETRY: successors_iter,\\n }, successors_iter(atom))\",\n \"def transitive_reduction(self, sorted_node):\\n \\n if self.is_cyclic() is False:\\n \\n visited = set()\\n path = []\\n\\n for i in sorted_node:\\n if i not in visited:\\n visited = self.transitive_reduction_helper(i, visited, path)\\n \\n print(\\\"Transitive reduction is completed.\\\")\\n \\n else:\\n print(\\\"Transitive reduction can only be performed on directed acyclic graph.\\\")\",\n \"def relation_set_has_contradictions(relations):\\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\\n return 1 < sum([has_cnc, has_decreases, has_increases])\",\n \"def cc_visited(ugraph):\\n\\tremain = []\\n\\tfor node in ugraph:\\n\\t\\tremain.append(node)\\n\\tconnected = []\\n\\twhile remain:\\n\\t\\tvisited = bfs_visited(ugraph, remain[0])\\n\\t\\tconnected.append(visited)\\n\\t\\tremain = [i for i in remain if not i in visited]\\n\\treturn connected\",\n \"def indirect(stack):\\n g = nx.Graph(stack)\\n for group in nx.connected_components(g):\\n yield from map(frozenset, combinations(group, 2))\",\n \"def find_conflicts(graph):\\n for node in graph:\\n for neighbour in node.neighbours:\\n for n in neighbour.neighbours:\\n if n is node:\\n continue\\n _log.info(\\\"Nodes %s and %s are in conflict.\\\" % (node, n))\\n node.add_conflict_with_node(n)\\n n.add_conflict_with_node(node)\",\n \"def _get_common_neighbour_node_pairs(self):\\n node_pairs = []\\n for node1 in self.graph.nodes():\\n for node2 in self.graph.nodes():\\n if node1 != node2:\\n neighbour_count = self.neighbour_counts[(node1, node2)]\\n if neighbour_count >= 1:\\n node_pairs.append((node1, node2))\\n return node_pairs\",\n \"def iter_all_nucleic_acids(self):\\n for model in self.model_list:\\n for chain in model.chain_list:\\n for frag in chain.iter_nucleic_acids():\\n yield frag\",\n \"def cfdProcessNodeTopology(self):\\r\\n self.nodeElements = self.cfdInvertConnectivity(self.elementNodes)\\r\\n self.nodeFaces = self.cfdInvertConnectivity(self.faceNodes)\",\n \"def all_pairs(self):\\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))\",\n \"def aga_contract_graph(adata, min_group_size=0.01, max_n_contractions=1000, copy=False):\\n adata = adata.copy() if copy else adata\\n if 'aga_adjacency_tree_confidence' not in adata.add: raise ValueError('run tool aga first!')\\n min_group_size = min_group_size if min_group_size >= 1 else int(min_group_size * adata.n_smps)\\n logg.info('contract graph using `min_group_size={}`'.format(min_group_size))\\n\\n def propose_nodes_to_contract(adjacency_tree_confidence, node_groups):\\n # nodes with two edges\\n n_edges_per_seg = np.sum(adjacency_tree_confidence > 0, axis=1).A1\\n for i in range(adjacency_tree_confidence.shape[0]):\\n if n_edges_per_seg[i] == 2:\\n neighbors = adjacency_tree_confidence[i].nonzero()[1]\\n for neighbors_edges in range(1, 20):\\n for n_cnt, n in enumerate(neighbors):\\n if n_edges_per_seg[n] == neighbors_edges:\\n logg.msg('merging node {} into {} (two edges)'\\n .format(i, n), v=4)\\n return i, n\\n # node groups with a very small cell number\\n for i in range(adjacency_tree_confidence.shape[0]):\\n if node_groups[str(i) == node_groups].size < min_group_size:\\n neighbors = adjacency_tree_confidence[i].nonzero()[1]\\n neighbor_sizes = [node_groups[str(n) == node_groups].size for n in neighbors]\\n n = neighbors[np.argmax(neighbor_sizes)]\\n logg.msg('merging node {} into {} '\\n '(smaller than `min_group_size` = {})'\\n .format(i, n, min_group_size), v=4)\\n return i, n\\n return 0, 0\\n\\n def contract_nodes(adjacency_tree_confidence, node_groups):\\n for count in range(max_n_contractions):\\n i, n = propose_nodes_to_contract(adjacency_tree_confidence, node_groups)\\n if i != 0 or n != 0:\\n G = nx.Graph(adjacency_tree_confidence)\\n G_contracted = nx.contracted_nodes(G, n, i, self_loops=False)\\n adjacency_tree_confidence = nx.to_scipy_sparse_matrix(G_contracted)\\n node_groups[str(i) == node_groups] = str(n)\\n for j in range(i+1, G.size()+1):\\n node_groups[str(j) == node_groups] = str(j-1)\\n else:\\n break\\n return adjacency_tree_confidence, node_groups\\n\\n size_before = adata.add['aga_adjacency_tree_confidence'].shape[0]\\n adata.add['aga_adjacency_tree_confidence'], adata.smp['aga_groups'] = contract_nodes(\\n adata.add['aga_adjacency_tree_confidence'], adata.smp['aga_groups'])\\n adata.add['aga_groups_order'] = np.unique(adata.smp['aga_groups'])\\n for key in ['aga_adjacency_full_confidence', 'aga_groups_original',\\n 'aga_groups_order_original', 'aga_groups_colors_original']:\\n if key in adata.add: del adata.add[key]\\n logg.info(' contracted graph from {} to {} nodes'\\n .format(size_before, adata.add['aga_adjacency_tree_confidence'].shape[0]))\\n logg.msg('removed adata.add[\\\"aga_adjacency_full_confidence\\\"]', v=4)\\n return adata if copy else None\",\n \"def _create_connections(self):\\n self.predecessors = {}\\n self.successors = {}\\n for nd in self.nodes:\\n self.predecessors[nd.name] = []\\n self.successors[nd.name] = []\\n\\n for (nd_out, nd_in) in self.edges:\\n self.predecessors[nd_in.name].append(nd_out)\\n self.successors[nd_out.name].append(nd_in)\",\n \"def connecting(node1, node2):\\n comp_list = []\\n \\\"\\\"\\\":type : list[components.Component]\\\"\\\"\\\"\\n if node1 == node2:\\n return []\\n for comp in node1.connected_comps:\\n if comp.neg == node2:\\n comp_list.append(comp)\\n elif comp.pos == node2:\\n comp_list.append(comp)\\n return comp_list\",\n \"def scc(graph, reverse_graph, nodes):\\n\\n out = defaultdict(list)\\n track = Track()\\n dfs_loop(reverse_graph, nodes, track)\\n sorted_nodes = sorted(track.finish_time,\\n key=track.finish_time.get, reverse=True)\\n track.current_time = 0\\n track.current_source = None\\n track.explored = set()\\n dfs_loop(graph, sorted_nodes, track)\\n for lead, vertex in groupby(sorted(track.leader, key=track.leader.get),\\n key=track.leader.get):\\n out[lead] = list(vertex)\\n\\n return out\",\n \"def narrative_consistency(self, metric='betweenness', nodes=None): # measures centrality\\n if metric == 'betweenness':\\n vals = nx.betweenness_centrality(self.graph)\\n elif metric == 'degree':\\n vals = {n[0]: n[1] for n in self.graph.degree()}\\n elif metric == 'closeness':\\n vals = nx.closeness_centrality(self.graph)\\n else:\\n vals_b = nx.betweenness_centrality(self.graph)\\n vals_d = {n[0]: n[1] for n in self.graph.degree()}\\n vals_c = nx.closeness_centrality(self.graph)\\n\\n min_ = min(vals_b.values())\\n delta = max(vals_b.values()) - min_\\n vals_b = {k: (v - min_) / delta for k, v in vals_b.items()}\\n\\n min_ = min(vals_d.values())\\n delta = max(vals_d.values()) - min_\\n vals_d = {k: (v - min_) / delta for k, v in vals_d.items()}\\n\\n min_ = min(vals_c.values())\\n delta = max(vals_c.values()) - min_\\n vals_c = {k: (v - min_) / delta for k, v in vals_c.items()}\\n\\n vals = {k: (v + vals_b.get(k, 0) + vals_c.get(k, 0)) / 3 for k, v in vals_d.items()}\\n\\n if nodes is None:\\n return sum(-math.log(v) for v in vals.values() if v > 0) / self.graph.number_of_nodes()\\n\\n return sum(-math.log(v) for k, v in vals.items() if v > 0 and k in nodes) / len(nodes)\",\n \"def findcc(self):\\n for vertex in self.graph.vertices:\\n if vertex not in self.preOrderNumbers:\\n self.dfs(vertex)\\n return self.scComponents\",\n \"def generate_connectivity_constraint_all(problem):\\n\\n if problem.num_vars == None:\\n problem.compute_num_var()\\n\\n ret = Constraint()\\n\\n # Iterator over all (v, t) subsets in the graph\\n for b, b_r in enumerate(problem.src):\\n # Convert each set in the iterator to (v,t) format\\n add_S = map(\\n lambda S: list(map(problem.get_time_augmented_n_t, S)),\\n problem.powerset_exclude_agent(b_r),\\n )\\n ret &= generate_connectivity_constraint(problem, [b], add_S)\\n\\n return ret\",\n \"def compute_relations(nodes: List[Node]) -> None:\\n # Calculate parents\\n for node in nodes:\\n node.parents = []\\n for node in nodes:\\n for child in node.children():\\n child.parents.append(node)\\n\\n def compute_dominators(\\n entry: Node,\\n parents: Callable[[Node], List[Node]],\\n dominators: Callable[[Node], Set[Node]],\\n immediately_dominates: Callable[[Node], List[Node]],\\n set_immediate_dominator: Callable[[Node, Optional[Node]], None],\\n ) -> None:\\n # See https://en.wikipedia.org/wiki/Dominator_(graph_theory)#Algorithms\\n # Note: if `n` is unreachable from `entry`, then *every* node will\\n # vacuously belong to `n`'s dominator set.\\n for n in nodes:\\n dominators(n).clear()\\n if n == entry:\\n dominators(n).add(n)\\n else:\\n dominators(n).update(nodes)\\n\\n changes = True\\n while changes:\\n changes = False\\n for node in nodes:\\n if node == entry:\\n continue\\n nset = dominators(node)\\n for parent in parents(node):\\n nset = nset.intersection(dominators(parent))\\n nset.add(node)\\n if len(nset) < len(dominators(node)):\\n assert nset.issubset(dominators(node))\\n dominators(node).intersection_update(nset)\\n changes = True\\n\\n # Compute immediate dominator, and the inverse relation\\n for node in nodes:\\n immediately_dominates(node).clear()\\n for node in nodes:\\n doms = dominators(node).difference({node})\\n # If `node == entry` or the flow graph is not reducible, `doms` may be empty.\\n # TODO: Infinite loops could be made reducible by introducing\\n # branches like `if (false) { return; }` without breaking semantics\\n if doms:\\n # There should be a unique max `len(dominators(d))` if the flowgraph\\n # is reducible. Fall back to largest index for irreducible graphs.\\n imdom = max(doms, key=lambda d: (len(dominators(d)), d.block.index))\\n immediately_dominates(imdom).append(node)\\n set_immediate_dominator(node, imdom)\\n else:\\n set_immediate_dominator(node, None)\\n for node in nodes:\\n immediately_dominates(node).sort(key=lambda x: x.block.index)\\n\\n def _set_immediate_dominator(node: Node, imdom: Optional[Node]) -> None:\\n node.immediate_dominator = imdom\\n\\n def _set_immediate_postdominator(node: Node, impdom: Optional[Node]) -> None:\\n node.immediate_postdominator = impdom\\n\\n entry = nodes[0]\\n terminal = nodes[-1]\\n assert isinstance(terminal, TerminalNode)\\n\\n # Compute dominators & immediate dominators\\n compute_dominators(\\n entry=entry,\\n parents=lambda n: n.parents,\\n dominators=lambda n: n.dominators,\\n immediately_dominates=lambda n: n.immediately_dominates,\\n set_immediate_dominator=_set_immediate_dominator,\\n )\\n\\n # Compute postdominators & immediate postdominators\\n # This uses the same algorithm as above, but with edges reversed\\n compute_dominators(\\n entry=terminal,\\n parents=lambda n: n.children(),\\n dominators=lambda n: n.postdominators,\\n immediately_dominates=lambda n: n.immediately_postdominates,\\n set_immediate_dominator=_set_immediate_postdominator,\\n )\\n\\n # Iterate over all edges n -> c and check for backedges, which define natural loops\\n for node in nodes:\\n for child in node.children():\\n if child not in node.dominators:\\n continue\\n # Found a backedge node -> child where child dominates node; child is the \\\"head\\\" of the loop\\n if child.loop is None:\\n child.loop = NaturalLoop(child)\\n child.loop.nodes |= {child, node}\\n child.loop.backedges.add(node)\\n for parent in nodes:\\n if reachable_without(parent, node, child):\\n child.loop.nodes.add(parent)\",\n \"def iter_nucleic_acids(self):\\n for chain in self.iter_chains():\\n for frag in chain.iter_nucleic_acids():\\n yield frag\",\n \"def CirculantGraph(n, adjacency):\\n from sage.graphs.graph_plot import _circle_embedding\\n\\n if not isinstance(adjacency,list):\\n adjacency=[adjacency]\\n\\n G = Graph(n, name=\\\"Circulant graph (\\\"+str(adjacency)+\\\")\\\")\\n _circle_embedding(G, list(range(n)))\\n\\n for v in G:\\n G.add_edges([(v,(v+j)%n) for j in adjacency])\\n\\n return G\",\n \"def increasing_cover_relations(self):\\n relations = []\\n size = self.size()\\n for i in range(1, size):\\n for j in range(i + 1, size + 1):\\n if self.le(i, j):\\n relations.append((i, j))\\n break\\n return relations\",\n \"def generate_computational_graph(RHS, schema):\\n computational_graph=dict()\\n for level in range(3):\\n #use brute force to generate candidates for each level\\n computational_graph[level]=[]\\n if level== 0:\\n for attribute in schema:\\n if attribute !=RHS:\\n computational_graph[level].append(set([attribute]))\\n\\n else:\\n for element1 in computational_graph[level-1]:\\n for element2 in computational_graph[0]:\\n newelement = element1.union(element2)\\n if newelement not in computational_graph[level]:\\n if len(newelement)==level+1:\\n computational_graph[level].append(newelement)\\n\\n return computational_graph\",\n \"def _anchored_successors(self, n):\\n\\n # loop on all outgoing edges\\n for t in self.successors(n):\\n \\n # if neighbor is anchored\\n # stop looking for (necessarily later) successors\\n if t.anchored:\\n yield t\\n continue\\n\\n # if neighbor is not anchored\\n # look one level deeper\\n for tt in self._anchored_successors(t):\\n yield tt\",\n \"def cX(cb):\\n allNodes = b.allNodes(group=cb)\\n for n in allNodes:\\n allNodes = allNodes + cX(n)\\n\\n return allNodes\",\n \"def neato_cooccurrence_graph( nC, v, labels, max_nodes = 10, fnam_stem = \\\"test\\\", label_nodes_directly = False, scale=1.0, min_node_size = 0.1 ):\\n \\n nv = v.astype( float32 ) / v.max()\\n\\n cutoff = cooccur_cutoff( nC, max_nodes );\\n\\n graph = pydot.Dot( graph_type = 'graph' )\\n graph.set_overlap(\\\"false\\\")\\n coords = zip(*(nC >= cutoff).nonzero())\\n\\n # make a dict of all nodes which are mentioned in the coords\\n nodes = {}\\n index = 1\\n for coord in set(chain.from_iterable(coords)) :\\n if not nodes.has_key( coord ) :\\n node = pydot.Node( str(coord) )\\n if v != None :\\n #print coord\\n label = labels[coord]\\n if label_nodes_directly :\\n node.set_label( label )\\n else :\\n node.set_label( str(index) )\\n #node.set_penwidth( nv[ coord ] )\\n node.set_fixedsize(\\\"true\\\")\\n node.set_width( max(min_node_size,scale *nv[ coord ]) )\\n node.set_shape(\\\"circle\\\")\\n nodes[ coord ] = node\\n graph.add_node( node )\\n index = index + 1\\n\\n for coord in coords :\\n \\n edge = pydot.Edge( nodes[coord[0]], nodes[coord[1]] )\\n edge.set_weight( nC[coord] )\\n edge.set_penwidth( nC[coord]*5 )\\n #edge.set_label( str(int(m[coord]) ))\\n graph.add_edge(edge)\\n\\n if not label_nodes_directly : \\n legend = pydot.Node( \\\"legend\\\" )\\n nodelist = nodes.items()\\n nodelist.sort( lambda a,b : cmp(node_index(a[1].get_label()),node_index(b[1].get_label())) )\\n legend.set_label( \\\"\\\\l\\\".join([x[1].get_label()+\\\":\\\"+labels[x[0]] for x in nodelist])+\\\"\\\\l\\\" )\\n legend.set_shape(\\\"box\\\")\\n graph.add_node(legend)\\n\\n #print graph.to_string()\\n graph.write_dot(fnam_stem+'.dot', prog='neato' )\\n graph.write_png(fnam_stem+'.png', prog='neato' )\\n #graph.write_pdf(fnam_stem+'.pdf', prog='neato' )\",\n \"def connectCns(cnxDict, nsRig=None, nsSkin=None):\\n for i, jnt in enumerate(cnxDict[\\\"joints\\\"]):\\n if nsSkin:\\n oJnt = pm.PyNode(nsSkin + \\\":\\\" + jnt)\\n else:\\n oJnt = pm.PyNode(jnt)\\n\\n if cnxDict[\\\"attrs\\\"][i][0]:\\n if nsRig:\\n oAttr = pm.PyNode(nsRig + \\\":\\\" + cnxDict[\\\"attrs\\\"][i][0])\\n else:\\n oAttr = pm.PyNode(cnxDict[\\\"attrs\\\"][i][0])\\n\\n oNode = oAttr.node()\\n oTrans = pm.listConnections(\\n pm.listConnections(oNode.inputMatrix)[0].matrixIn[0])\\n pm.parentConstraint(oTrans, oJnt, mo=True)\\n pm.scaleConstraint(oTrans, oJnt, mo=True)\",\n \"def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\\n for downstream_key in self.downstream_deps:\\n relationship = GraphRelationship(\\n start_key=self.column_key,\\n start_label=ColumnMetadata.COLUMN_NODE_LABEL,\\n end_label=ColumnMetadata.COLUMN_NODE_LABEL,\\n end_key=downstream_key,\\n type=ColumnLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\\n reverse_type=ColumnLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\\n attributes={}\\n )\\n yield relationship\",\n \"def canonical_coloring_label_1(G,c):\\n \\n H = G.copy()\\n #H.allow_loops( true )\\n\\n for i in c:\\n print( i )\\n H.add_edges([(i,j) for j in c[i]])\\n\\n P = [G.vertices(), c.keys()]\\n return H.canonical_label(partition=P)\",\n \"def calc_critical_paths(self):\\n visited = set([])\\n nodes = set(self.get_leaves())\\n\\n while nodes:\\n n = nodes.pop()\\n n.update_critical_path(n.latency())\\n visited.add(n)\\n cp = n.critical_path\\n\\n for p in n.parents:\\n p.update_critical_path(cp + p.latency())\\n # if p not in visited:\\n nodes.add(p)\\n # visited.add(p)\\n\\n for d in n.serial_parents:\\n d.update_critical_path(cp + 1)\\n # if d not in visited:\\n nodes.add(d)\\n # visited.add(d)\",\n \"def compute_centrality_for_nodes(graph: nx.Graph):\\n nodes_centralities = {}\\n degree_centralities = nx.degree_centrality(graph)\\n betweeness_centralities = nx.betweenness_centrality(graph, normalized=True)\\n closeness_centralities = nx.closeness_centrality(graph)\\n for node in graph.nodes:\\n closeness = closeness_centralities[node]\\n degree = degree_centralities[node]\\n betweeness = betweeness_centralities[node]\\n nodes_centralities[node] = {\\n \\\"degree\\\": degree,\\n \\\"closeness\\\": closeness,\\n \\\"betweeness\\\": betweeness\\n }\\n\\n return nodes_centralities\",\n \"def graph():\\n\\n graph = {'A': ['B', 'C'],\\n 'B': ['C', 'D'],\\n 'C': ['D'],\\n 'D': ['C'],\\n 'E': ['F'],\\n 'F': ['C']}\\n\\n def generate_edges(graph):\\n \\\"\\\"\\\" Convert the dict representation of a graph into a list one\\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\\n \\\"\\\"\\\"\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\\n\\n a = generate_edges(graph=graph)\\n print(a)\",\n \"def part1c_0():\\n xs = exampleInput\\n T = submission.computeEdgeMarginals(simpleCRF, xs)\\n for t in T:\\n grader.requireIsEqual( 1.0, sum(t.values()) )\",\n \"def clusters_connected( self):\\n def check_connected( k, vertices, edges):\\n dads = {}\\n for p in vertices:\\n dads[p] = p\\n\\n def Find( c):\\n while c != dads[c]:\\n c = dads[c]\\n return c\\n\\n def Union( p, q):\\n dads[Find(p)] = Find(q)\\n\\n for p,q in edges:\\n Union( p, q)\\n\\n stuff = set([ Find(p) for (k,p) in dads.items()])\\n assert len(stuff) == 1, \\\"More than one partition\\\"\\n\\n vertices = collections.defaultdict( list)\\n for p in itertools.product( range(self.n), repeat=2):\\n vertices[self.raster[p]].append( p)\\n\\n def X():\\n for x in range(self.n-1):\\n for y in range(self.n):\\n yield (x,y),(x+1,y)\\n\\n def Y():\\n for x in range(self.n):\\n for y in range(self.n-1):\\n yield (x,y),(x,y+1)\\n\\n connections = collections.defaultdict( list)\\n for (p,q) in itertools.chain( X(), Y()):\\n if self.raster[p] == self.raster[q]:\\n connections[self.raster[p]].append( ( p, q))\\n\\n for (k,v) in vertices.items():\\n check_connected( k, v, connections[k])\",\n \"def cocite(G,min_citations = 2):\\n\\n\\n if not G.is_directed():\\n msg = \\\"The cocitation algorithm requires a directed citation graph as an input.\\\"\\n raise nx.NetworkXError(msg)\\n\\n #assert type(G) == nx.classes.digraph.DiGraph\\n\\n edges = {}\\n #for each node\\n for n in G.nodes():\\n # for each outward edge (citing)\\n out = G.out_edges(n)\\n for i in out:\\n for j in out:\\n if i==j: break\\n\\n pair = tuple(set([i[1],j[1]]))\\n try: edges[pair] = edges[pair] + 1\\n except: edges[pair] = 1\\n\\n CC = G.to_undirected() # this returns a deepcopy\\n CC = nx.create_empty_copy(CC, with_data=True)\\n\\n edgelist = [(i[0][0],i[0][1],i[1]) for i in edges.viewitems() if i[1]>min_citations]\\n\\n CC.add_weighted_edges_from(edgelist)\\n\\n return CC\",\n \"def connected_components(graph):\\n all_nodes = list(graph.keys())\\n\\n counter = 0\\n explored = set()\\n components = []\\n for node in all_nodes:\\n if node not in explored:\\n counter += 1\\n visited = bfs(graph, node)\\n components.append(visited)\\n explored = explored.union(visited)\\n\\n return explored, components, counter\",\n \"def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\\n for downstream_key in self.downstream_deps:\\n relationship = GraphRelationship(\\n start_key=self.table_key,\\n start_label=TableMetadata.TABLE_NODE_LABEL,\\n end_label=TableMetadata.TABLE_NODE_LABEL,\\n end_key=downstream_key,\\n type=TableLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\\n reverse_type=TableLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\\n attributes={}\\n )\\n yield relationship\",\n \"def findDiscripancies(taxonomy):\\n i = 0\\n for entry in taxonomy:\\n if entry['parentName'] != None:\\n print entry['nodeName']\\n if entry['nodeName'].lower() == entry['parentName'].lower():\\n i += 1\\n print \\\"No of same nodes = {} \\\" .format(i)\",\n \"def likely_pairs(self, k=2):\\n for a in self.G.nodes():\\n if not self.eligible_node(a):\\n continue\\n for b in neighbourhood(self.G, a, k):\\n if not self.eligible_node(b):\\n continue\\n yield (a, b)\",\n \"def run_tests(g: Graph) -> None:\\n print( g.nodes() , \\\"->\\\" , ', '.join([f\\\"{l}\\\" for l in g.scc()]) , f\\\"({g.cyclic()})\\\" )\\n for n in g.nodes():\\n for m in [m for m in g.nodes() if m != n]:\\n p = g.path(n,m)\\n if p is not None:\\n assert p[0] == n\\n assert p[-1] == m\\n for i in range(1,len(p)):\\n assert g.is_edge(p[i-1], p[i])\\n print(\\\" \\\", n, \\\"->\\\", m, \\\":\\\", ' -> '.join([f\\\"{v}\\\" for v in p]))\",\n \"def identify_coref_chains(dialog):\\n\\n for r_id, datum in enumerate(dialog['dialog']):\\n label = datum['template']\\n if label in gvars.METAINFO['independent_questions']:\\n dialog['graph']['history'][r_id + 1]['dependence'] = None\\n continue\\n\\n if (label == 'exist-attribute-group' or label == 'count-attribute-group' or\\n label == 'count-all-group'):\\n dialog['graph']['history'][r_id + 1]['dependence'] = r_id - 1\\n continue\\n\\n if 'imm' in label:\\n dialog['graph']['history'][r_id + 1]['dependence'] = r_id - 1\\n continue\\n\\n if 'early' in label:\\n # Go over previous history.\\n cur_history = dialog['graph']['history'][r_id + 1]\\n assert 'focus_id' in cur_history and 'focus_desc' in cur_history,\\\\\\n 'More focus objects than one, no focus objects!'\\n focus_id = cur_history['focus_id']\\n for attr in gvars.METAINFO['attributes']:\\n if attr in cur_history['focus_desc']: break\\n\\n history = dialog['graph']['history'][:r_id + 1]\\n for hist_id, hist_datum in enumerate(history):\\n for obj in hist_datum['objects']:\\n if obj['id'] == focus_id and attr in obj:\\n dialog['graph']['history'][r_id + 1]['dependence'] = hist_id - 1\\n break\\n return dialog\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def cross_transitivity_sparse(self, node_list1, node_list2):\\n cross_degree = self.cross_degree(node_list1, node_list2)\\n\\n # Get sparse adjacency matrix\\n A = self.sp_A[node_list1+node_list2, :][:, node_list1+node_list2]\\n # Get subnetwork sizes\\n N1, N2 = len(node_list1), len(node_list2)\\n # Initialize\\n cross_transitivity = 0.0\\n # Set counter\\n counter_triangles = 0.0\\n counter_triples = 0.0\\n # Calculate cross transitivity from subnetwork 1 to subnetwork 2\\n # Loop over nodes in subnetwork 1\\n for i in range(N1):\\n node1 = i\\n if cross_degree[i] > 1:\\n # Loop over unique pairs of nodes in subnetwork 2\\n for j in range(N1, N1+N2):\\n node2 = j\\n for k in range(N1, j):\\n node3 = k\\n if A[node1, node2] == 1 and A[node1, node3] == 1:\\n counter_triples += 1\\n if A[node2, node3] == 1:\\n counter_triangles += 1\\n\\n if counter_triples:\\n cross_transitivity = counter_triangles / counter_triples\\n return cross_transitivity\",\n \"def enumerate_links_around_node(self, node):\\n\\n l0 = self.node_link[node]\\n l = l0\\n edges = []\\n traversing = True\\n while traversing:\\n edges.append(l)\\n v = l[0]\\n if v == node:\\n l = self.pred_right[l]\\n else:\\n l = self.pred_left[l]\\n if l0 == l:\\n traversing = False\\n if l0[1] == l[0] and l0[0] == l[1]:\\n traversing = False\\n #print v, l\\n #raw_input('here')\\n return edges\",\n \"def generate_constraints_between_chains(self):\\n node_to_chain_mapping = defaultdict(set)\\n # collect all places where each node is used and at what subchain index\\n for chain_idx in range(len(self.chains)):\\n chain = self.chains[chain_idx]\\n for subchain_idx in range(len(chain)):\\n parent, child = chain[subchain_idx]\\n node_to_chain_mapping[parent].add(\\n AbstractConstraint(chain_idx, subchain_idx)\\n )\\n # don't forget about the final child in the chain (parents are already accounted for)\\n final_parent, final_child = chain[-1]\\n node_to_chain_mapping[final_child].add(\\n AbstractConstraint(chain_idx, len(chain))\\n )\\n # our final mapping correlates constraints on a per-chain basis\\n # e.g. for chain index 0 at subchain index 1, we have a constraint (shared node) in chain 2\\n chain_constraints = list()\\n for chain_idx in range(len(self.chains)):\\n chain = self.chains[chain_idx]\\n chain_constraint = [set() for i in range(len(chain) + 1)]\\n for subchain_idx in range(len(chain)):\\n parent, child = chain[subchain_idx]\\n node_constraints = node_to_chain_mapping[parent]\\n for constraint in node_constraints:\\n if constraint.chain_index != chain_idx:\\n chain_constraint[subchain_idx].add(constraint)\\n # don't forget about the final child in the chain (parents are already accounted for)\\n final_parent, final_child = chain[-1]\\n node_constraints = node_to_chain_mapping[final_child]\\n for constraint in node_constraints:\\n if constraint.chain_index != chain_idx:\\n chain_constraint[len(chain)].add(constraint)\\n chain_constraints.append(chain_constraint)\\n return chain_constraints\",\n \"def get_relations(log):\\n # finding loops of length two\\n # ordering relations\\n triangle = {}\\n for trace in log:\\n i = 0\\n while i < len(trace) - 2:\\n current = trace.__getitem__(i)\\n successor = trace.__getitem__(i + 1)\\n successor2 = trace.__getitem__(i + 2)\\n if current == successor2:\\n if current in triangle:\\n triangle[current].append(successor)\\n else:\\n triangle[current] = [successor]\\n i += 1\\n for key, value in triangle.items():\\n triangle[key] = set(value)\\n square = {}\\n for key in triangle:\\n for element in triangle[key]:\\n if element in triangle:\\n if key in triangle[element]:\\n if key in square and element in square:\\n square[key].append(element)\\n square[element].append(key)\\n elif key in square and element not in square:\\n square[key].append(element)\\n square[element] = [key]\\n elif key not in square and element in square:\\n square[key] = [element]\\n square[element].append(key)\\n else:\\n square[key] = [element]\\n square[element] = [key]\\n for key, value in square.items():\\n square[key] = set(value)\\n # ordering relation following\\n follows = {}\\n for trace in log:\\n i = 0\\n while i < len(trace) - 1:\\n current = trace.__getitem__(i)\\n successor = trace.__getitem__(i + 1)\\n if current in follows:\\n if successor not in follows[current]:\\n follows[current].append(successor)\\n else:\\n follows[current] = [successor]\\n i += 1\\n # transforming list to set\\n for key, value in follows.items():\\n follows[key] = set(value)\\n # ordering relation causal\\n causal = {}\\n if len(square) != 0:\\n for key in follows:\\n for element in follows[key]:\\n if element in follows:\\n if key in square:\\n if (not (key in follows[element])) or (element in square[key]):\\n if key in causal:\\n causal[key].append(element)\\n else:\\n causal[key] = [element]\\n else:\\n if (not (key in follows[element])):\\n if key in causal:\\n causal[key].append(element)\\n else:\\n causal[key] = [element]\\n else:\\n if key in causal:\\n causal[key].append(element)\\n else:\\n causal[key] = [element]\\n else:\\n for key in follows:\\n for element in follows[key]:\\n if element in follows:\\n if (not (key in follows[element])):\\n if key in causal:\\n causal[key].append(element)\\n else:\\n causal[key] = [element]\\n else:\\n if key in causal:\\n causal[key].append(element)\\n else:\\n causal[key] = [element]\\n\\n for key, value in causal.items():\\n causal[key] = set(value)\\n # ordering relation unrelated if no other ordering is applied\\n # ordering relation parallel\\n parallel = {}\\n if len(square) != 0:\\n for key in follows:\\n for element in follows[key]:\\n if element in follows:\\n if key in follows[element]:\\n if element in follows[key]:\\n if key in square:\\n if not element in square[key]:\\n if key in parallel:\\n parallel[key].append(element)\\n else:\\n parallel[key] = [element]\\n else:\\n if key in parallel:\\n parallel[key].append(element)\\n else:\\n parallel[key] = [element]\\n\\n else:\\n for key in follows:\\n for element in follows[key]:\\n if element in follows:\\n if key in follows[element]:\\n if element in follows[key]:\\n if key in parallel:\\n parallel[key].append(element)\\n else:\\n parallel[key] = [element]\\n\\n for key, value in parallel.items():\\n parallel[key] = set(value)\\n return causal, parallel, follows\",\n \"def _count_concordant_pairs(preds: Tensor, target: Tensor) ->Tensor:\\n return torch.cat([_concordant_element_sum(preds, target, i) for i in range(preds.shape[0])]).sum(0)\",\n \"def __CI_helper(self, inh):\\r\\n list_of_ci_relation = list()\\r\\n if inh is None:\\r\\n logger.info(\\\"There are no CI relations\\\")\\r\\n else:\\r\\n for parent_and_child in inh:\\r\\n parent = parent_and_child.attrib.get(\\\"ci\\\")\\r\\n child = parent_and_child.attrib.get(\\\"cj\\\")\\r\\n for inner_parent_and_child in inh:\\r\\n inner_parent = inner_parent_and_child.attrib.get(\\\"ci\\\")\\r\\n inner_child = inner_parent_and_child.attrib.get(\\\"cj\\\")\\r\\n if inner_parent == parent and inner_child != child:\\r\\n ci_tuple = (parent, child, inner_child)\\r\\n list_of_ci_relation.append(ci_tuple)\\r\\n logger.debug(\\\"Found CI: (%s, %s, %s)\\\" % (ci_tuple[0], ci_tuple[1], ci_tuple[2]))\\r\\n list_of_ci_relation = list(dict.fromkeys(list_of_ci_relation))\\r\\n index = 0\\r\\n while True:\\r\\n if index == len(list_of_ci_relation):\\r\\n break\\r\\n for ci in list_of_ci_relation:\\r\\n if index == len(list_of_ci_relation):\\r\\n break\\r\\n if list_of_ci_relation[index] == ci:\\r\\n continue\\r\\n # check if both parents are the same (index zero in tuple is for parent)\\r\\n if ci[0] == list_of_ci_relation[index][0]:\\r\\n if sorted(ci) == sorted(list_of_ci_relation[index]):\\r\\n del list_of_ci_relation[index]\\r\\n index = 0\\r\\n index = index + 1\\r\\n return list_of_ci_relation\",\n \"def MatchRelationshipConfrontation(C):\\n for c in C:\\n if c.relationships is None:\\n continue\\n for i, longname in enumerate(c.relationships):\\n found = False\\n for cor in C:\\n if longname.lower() == cor.longname.lower():\\n c.relationships[i] = cor\\n found = True\\n return C\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def test_2():\\n h = iotbx.pdb.input(source_info=None, lines=test_pdb_2).construct_hierarchy()\\n asc = h.atom_selection_cache()\\n ncs_inp = iotbx.ncs.input(\\n hierarchy=h,\\n params=ncs_pars.ncs_search)\\n ncs_groups = ncs_inp.get_ncs_restraints_group_list()\\n assert len(ncs_groups) == 1\\n # group 1\\n assert ncs_groups[0].master_iselection.all_eq(\\n asc.selection(string = \\\"chain A\\\").iselection())\\n g1_c = ncs_groups[0].copies\\n assert len(g1_c)==1\\n assert g1_c[0].iselection.all_eq(\\n asc.selection(string = \\\"chain B\\\").iselection())\",\n \"def connectivity_matrix(self):\\n # TODO: make this more memory efficient by ordering i,j in code when needed.\\n temp = []\\n for i in range(self.n_atom):\\n for j in range(i+1, self.n_atom):\\n if self.bond(i, j):\\n temp.append([i+1, j+1])\\n self.connect = np.asarray(temp)\",\n \"def get_inconsistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def test_is_strongly_connected(self):\\n G = DiGraph([(0, 1), (1, 2), (2, 0)])\\n assert_true(is_strongly_connected(G))\",\n \"def get_all_arcs(self):\\n return [ (i, j) for i in self.constraints for j in self.constraints[i] ]\",\n \"def cousin(self, a, b):\\n a_node = self.names_to_nodes[a]\\n b_node = self.names_to_nodes[b]\\n \\n def build_branch(node):\\n branch = [node]\\n parent = node.get_parent()\\n while parent != None:\\n branch.append(parent)\\n parent = parent.get_parent()\\n return branch\\n \\n a_branch = build_branch(self.names_to_nodes[a])\\n b_branch = build_branch(self.names_to_nodes[b])\\n \\n def branch_distance(a_node, b_node):\\n a_distance = 0\\n b_distance = 0\\n a_parent = a_node.get_parent()\\n b_parent = b_node.get_parent()\\n if a_parent == None:\\n return a_distance\\n if b_parent == None:\\n return b_distance\\n while a_parent not in b_branch and a_parent != None:\\n a_distance += 1\\n a_parent = a_parent.get_parent()\\n while b_parent not in a_branch and b_parent != None:\\n b_distance += 1 \\n b_parent = b_parent.get_parent()\\n cousin_tuple = (min(a_distance, b_distance), abs(a_distance - b_distance))\\n return cousin_tuple \\n \\n for m_a in a_branch:\\n if m_a == b_node:\\n return (-1,0)\\n for m_b in b_branch:\\n if m_b == a_node:\\n return (-1,0)\\n if self.names_to_nodes[a] == self.names_to_nodes[b]:\\n return (-1, 0)\\n else:\\n return branch_distance(a_node, b_node)\",\n \"def coherence(self, network):\\n\\n # Initialise coherence\\n coherence = 0\\n\\n for edge in list(network.edges(data='constraint')):\\n if edge[2] == 'positive':\\n if network.nodes[edge[0]]['truth_value'] == \\\\\\n network.nodes[edge[1]]['truth_value']:\\n coherence += 1\\n else:\\n coherence -= 1\\n elif edge[2] == 'negative':\\n if network.nodes[edge[0]]['truth_value'] == \\\\\\n network.nodes[edge[1]]['truth_value']:\\n coherence -= 1\\n else:\\n coherence += 1\\n\\n return coherence\",\n \"def compute_cpts_network(df, network):\\n P = dict()\\n for idx, pair in enumerate(network):\\n if pair.parents is None:\\n cpt = CPT.from_factor(Factor.from_data(df, cols=[pair.node])).normalize()\\n # cpt = CPT(marginal_distribution, conditioned=[pair.node]).normalize()\\n else:\\n # todo: there should be a from_data at CPT\\n cpt = CPT.from_factor(Factor.from_data(df, cols=[*pair.parents, pair.node])).normalize()\\n # cpt = CPT(joint_distribution, conditioned=[pair.node]).normalize()\\n\\n # add conditional distribution to collection\\n P[pair.node] = cpt\\n return P\",\n \"def get_connected_nodes(self, node):\\n assert node in self.nodes, \\\"No node \\\"+str(node)+\\\" in graph \\\"+str(self)\\n result = [x.node2 for x in self.edges if x.node1 == node]\\n result += [x.node1 for x in self.edges if x.node2 == node]\\n return sorted(result)\",\n \"def circulant_gen(min_order, max_order):\\n\\n for num_vertices in range(min_order, max_order + 1):\\n all_j_values = [x for x in range(1, floor(num_vertices / 2.0))]\\n j_values_iter = powerset(all_j_values)\\n\\n # for every possible offset combination\\n for j_value_set in j_values_iter:\\n # get the adjacency matrix of the circulant graph\\n adj = circulant_adj(j_value_set, num_vertices)\\n G = nx.from_numpy_matrix(adj)\\n\\n if G.size() > 0 and nx.is_connected(G):\\n yield (G, name_circulant(num_vertices, j_value_set))\",\n \"def nsi_cross_closeness_centrality(self, node_list1, node_list2):\\n shortest_paths = self.path_lengths()\\n node_weights = self.node_weights\\n\\n nsi_shortest_paths = shortest_paths + np.eye(len(shortest_paths))\\n nsi_shortest_paths[np.isinf(nsi_shortest_paths)] = self.N - 1\\n\\n nsi_cross_paths = nsi_shortest_paths[node_list1, :][:, node_list2]\\n W = sum(node_weights[node_list2])\\n return W / np.dot(nsi_cross_paths, node_weights[node_list2])\",\n \"def test_acyclic_chains():\\n names = ['robot', 'box1', 'box2']\\n chains = lambda: FactoredRandomGeometricGraph.acyclic_chains(names)\\n\\n expected_number = 16\\n actual_number = sum(1 for _ in chains())\\n assert actual_number == expected_number, \\\\\\n \\\"Expected {} chains; actual value was {}\\\".format(\\n expected_number, actual_number)\\n\\n assert all(\\n FactoredRandomGeometricGraph.is_acyclic(chain)\\n for chain in chains())\",\n \"def complex_network_mapping(graph):\\n vect = []\\n\\n n = nx.number_of_nodes(graph)\\n e = nx.number_of_edges(graph)\\n print n, e\\n\\n# adj = nx.adjacency_matrix(graph).toarray()\\n# adj_bin = np.where(adj > 0, 1., 0.)\\n# adj_conn = 1 - adj\\n adj_bin = nx.adjacency_matrix(graph).toarray()\\n adj_bin = np.array(adj_bin, dtype=np.float)\\n\\n # Node Betweenness binary\\n bt_bin = nx.betweenness_centrality(graph).values()\\n avg_btb = np.mean(bt_bin)\\n vect.append(avg_btb)\\n\\n # Edge betweenness\\n ebt = np.array(nx.edge_betweenness_centrality(graph).values())\\n vect.append(np.mean(ebt))\\n\\n # Eigen vector centrality binary\\n evc_bin = eigenvector_centrality_und(adj_bin)\\n avg_evcb = np.mean(evc_bin)\\n vect.append(avg_evcb)\\n\\n # Flow coefficient\\n _, flow_bin, _ = flow_coef_bd(adj_bin)\\n avg_flow = np.mean(flow_bin)\\n vect.append(avg_flow)\\n\\n # Kcoreness centrality\\n kcor_bin, _ = kcoreness_centrality_bu(adj_bin)\\n avg_kcor = np.mean(kcor_bin)\\n vect.append(avg_kcor)\\n\\n # Degree assortivity\\n dac = nx.degree_assortativity_coefficient(graph)\\n vect.append(dac)\\n\\n # Page rank centrality\\n# pgr_wei = pagerank_centrality(adj_bin, d=0.85)\\n# avg_pgr = np.mean(pgr_wei)\\n# vect.append(avg_pgr)\\n\\n # Rich club coefficient\\n# rcc = nx.rich_club_coefficient(graph).values()\\n# avg_rcc = np.mean(rcc)\\n# vect.append(avg_rcc)\\n\\n # Transitivity\\n tr = nx.transitivity(graph)\\n vect.append(tr)\\n\\n # average clustering\\n avg_clst = nx.average_clustering(graph)\\n vect.append(avg_clst)\\n\\n glb_ef = efficiency_bin(adj_bin)\\n vect.append(glb_ef)\\n\\n return vect\",\n \"def get_dependency_subgraphs(graph, node_attrib='label', edge_attrib='label'):\\n assert nx.is_directed_acyclic_graph(graph)\\n for n in xrange(graph.number_of_nodes()):\\n for subnodes in itertools.combinations(graph.nodes(), n+1):\\n subgraph_candidate = graph.subgraph(subnodes)\\n if is_dependency_subgraph(graph, subgraph_candidate,\\n node_attrib=node_attrib,\\n edge_attrib=edge_attrib):\\n yield subgraph_candidate\",\n \"def msep_from_given(self, A, C=set()):\\n\\n A = core_utils.to_set(A)\\n C = core_utils.to_set(C)\\n\\n determined = set()\\n descendants = set()\\n\\n for c in C:\\n determined.add(c)\\n descendants.add(c)\\n self._add_upstream(descendants, c)\\n\\n reachable = set()\\n i_links = set()\\n labeled_links = set()\\n\\n for a in A:\\n i_links.add((None, a))\\n reachable.add(a)\\n\\n while True:\\n i_p_1_links = set()\\n # Find all unlabled links v->w adjacent to at least one link u->v labeled i, such that (u->v,v->w) is a legal pair.\\n for link in i_links:\\n u, v = link\\n for w in self._adjacent[v]:\\n if not u == w and (v, w) not in labeled_links:\\n if self._is_collider(u, v, w): # Is collider?\\n if v in descendants:\\n i_p_1_links.add((v, w))\\n reachable.add(w)\\n else: # Not collider\\n if v not in determined:\\n i_p_1_links.add((v, w))\\n reachable.add(w)\\n\\n if len(i_p_1_links) == 0:\\n break\\n\\n labeled_links = labeled_links.union(i_links)\\n i_links = i_p_1_links\\n\\n return self._nodes.difference(A).difference(C).difference(reachable)\",\n \"def calc_process_cohesion(partitions, graph):\\n ch = 0\\n for part in partitions:\\n crc = calc_community_relation_cohesion(part, graph)\\n cic = calc_community_information_cohesion(part, graph)\\n ch = ch + (crc * cic)\\n ch = ch / len(partitions)\\n return ch\",\n \"def connections(self, src=False, dst=True, params=True): \\n conns = []\\n if params:\\n if src:\\n #grab the node params that this node is a src to\\n edges = self.parent.graph.out_edges(self, data=True) \\n conns.extend([ edge[2][\\\"dst_param\\\"] for edge in edges ])\\n if dst:\\n #grab the node param that this node is a dst to\\n edges = self.parent.graph.in_edges(self, data=True) \\n conns.extend([ edge[2][\\\"src_param\\\"] for edge in edges ])\\n else: \\n if src:\\n conns.extend(self.parent.graph.successors(self))\\n if dst:\\n conns.extend(self.parent.graph.predecessors(self))\\n \\n return conns\",\n \"def connect_all(graph, nodeset):\\n for element in nodeset:\\n graph.add_node(element)\\n for element1 in nodeset:\\n for element2 in nodeset:\\n if not element1 == element2:\\n graph.add_edge(element1, element2)\\n return graph\",\n \"def reactions(self):\\n for node in self.graph:\\n if not isinstance(node, Molecule):\\n yield node\",\n \"def contract(self, cycle):\\n # create a new id to represent the cycle in the resulting graph.\\n new_id = Digraph.new_node_id\\n Digraph.new_node_id += 1\\n\\n # we store links that cross into and out of the cycle in these maps. the\\n # to_cycle map contains links reaching into the cycle, and is thus a map\\n # from each target node in the cycle to a list of source nodes that\\n # reach that target from outside the cycle. the from_cycle map contains\\n # links going out from the cycle, and is thus a map from each source\\n # node in the cycle to a list of target nodes outside the cycle.\\n to_cycle = collections.defaultdict(list)\\n from_cycle = collections.defaultdict(list)\\n\\n scores = {}\\n labels = {}\\n succs = collections.defaultdict(list)\\n for source, target in self.iteredges():\\n if source in cycle:\\n if target not in cycle:\\n from_cycle[target].append(source)\\n elif target in cycle:\\n # we know source is not in cycle from above.\\n to_cycle[source].append(target)\\n else:\\n succs[source].append(target)\\n succs[target]\\n scores[source, target] = self.get_score(source, target)\\n labels[source, target] = self.get_label(source, target)\\n\\n old_edges = collections.defaultdict(list)\\n\\n # for each target in our graph that's reachable from the cycle, add an\\n # edge from our new node to that target, with an appropriate score.\\n for target, sources in from_cycle.items():\\n succs[new_id].append(target)\\n max_score = -1e100\\n max_source = None\\n for s in sources:\\n score = self.get_score(s, target)\\n if score > max_score:\\n max_score = score\\n max_source = s\\n old_edges[max_source].append(target)\\n scores[new_id, target] = max_score\\n labels[new_id, target] = self.get_label(max_source, target)\\n\\n # before we handle the to_cycle map, we need to build some convenience\\n # information for the cycle -- total score, and predecessor edges.\\n pred = {}\\n cycle_score = 0\\n for s, t in cycle.iteredges():\\n pred[t] = s\\n cycle_score += self.get_score(s, t)\\n\\n # for each source in our graph that reaches into the cycle, add an edge\\n # from the source to our new node, with an appropriate edge score.\\n for source, targets in to_cycle.items():\\n succs[source].append(new_id)\\n max_score = -1e100\\n max_target = None\\n for t in targets:\\n score = self.get_score(source, t) - self.get_score(pred[t], t)\\n if score > max_score:\\n max_score = score\\n max_target = t\\n old_edges[source].append(max_target)\\n scores[source, new_id] = cycle_score + max_score\\n labels[source, new_id] = self.get_label(source, max_target)\\n\\n return (\\n new_id,\\n old_edges,\\n Digraph(\\n succs, lambda s, t: scores[s, t], lambda s, t: labels[s, t]\\n ),\\n )\",\n \"def _initializeAdjacencyList(self):\\n\\n if self.comm.rank == 0:\\n # First, create a dictionary of common edges shared by components\\n edgeToFace = {}\\n for elemID in self.bdfInfo.elements:\\n elemInfo = self.bdfInfo.elements[elemID]\\n elemConn = elemInfo.nodes\\n compID = self.meshLoader.nastranToTACSCompIDDict[elemInfo.pid]\\n nnodes = len(elemConn)\\n if nnodes >= 2:\\n for j in range(nnodes):\\n nodeID1 = elemConn[j]\\n nodeID2 = elemConn[(j + 1) % nnodes]\\n\\n if nodeID1 < nodeID2:\\n key = (nodeID1, nodeID2)\\n else:\\n key = (nodeID2, nodeID1)\\n\\n if key not in edgeToFace:\\n edgeToFace[key] = [compID]\\n elif compID not in edgeToFace[key]:\\n edgeToFace[key].append(compID)\\n\\n # Now we loop back over each element and each edge. By\\n # using the edgeToFace dictionary, we can now determine\\n # which components IDs (jComp) are connected to the\\n # current component ID (iComp).\\n self.adjacentComps = []\\n\\n for edgeKey in edgeToFace:\\n if len(edgeToFace[edgeKey]) >= 2:\\n for i, iComp in enumerate(edgeToFace[edgeKey][:-1]):\\n for jComp in edgeToFace[edgeKey][i + 1 :]:\\n if iComp < jComp:\\n dvKey = (iComp, jComp)\\n else:\\n dvKey = (jComp, iComp)\\n if dvKey not in self.adjacentComps:\\n self.adjacentComps.append(dvKey)\\n\\n else:\\n self.adjacentComps = None\\n\\n # Wait for root\\n self.comm.barrier()\",\n \"def perms_are_connected(g, n):\\n from sage.graphs.graph import Graph\\n G = Graph()\\n if g:\\n G.add_vertices(g[0].domain())\\n for p in g:\\n G.add_edges(p.dict().items())\\n return G.is_connected()\",\n \"def iter_node(self,i):\\n nd = self.nodes[i]\\n for kn in nd.get_close():\\n # for kn in nd.get_known():\\n # for kn in nd.neighbours:\\n kn_node = self.nodes[kn.lindex]\\n nd.add_known_nodes(kn.path_len,kn_node.get_close())\",\n \"def iter_nodes(self):\",\n \"def cluster_connectivity(G, weight='weight'):\\n\\t# 1) indexing the edges by community\\n\\tsum_edges_dic = { com : {} for com in range(G.nb_communities)}\\n\\tfor node1, node2 in G.edges():\\n\\t\\tcomm1 = G.nodes[node1]['community']\\n\\t\\tcomm2 = G.nodes[node2]['community']\\n\\t\\tif comm2 not in sum_edges_dic[comm1]:\\n\\t\\t\\tsum_edges_dic[comm1][comm2] = 0\\n\\t\\t\\tsum_edges_dic[comm2][comm1] = 0\\n\\t\\telse:\\n\\t\\t\\tif weight is None:\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += 1\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += 1\\n\\t\\t\\telse:\\t\\n\\t\\t\\t\\tsum_edges_dic[comm1][comm2] += G.edges[node1, node2][weight]\\n\\t\\t\\t\\tsum_edges_dic[comm2][comm1] += G.edges[node1, node2][weight]\\n\\tc_connectivity = {}\\n\\t# 2) computing the connectivity\\n\\tfor com in sum_edges_dic:\\n\\t\\tin_out_edges = sum(sum_edges_dic[com].values())\\n\\t\\tc_connectivity[com] = round(- np.log2(sum_edges_dic[com][com] / in_out_edges),3) \\n\\treturn c_connectivity\",\n \"def scc(self):\\n return self.to_ddm().scc()\",\n \"def decreasing_cover_relations(self):\\n relations = []\\n for i in range(self.size(), 1, -1):\\n for j in range(i - 1, 0, -1):\\n if self.le(i, j):\\n relations.append((i, j))\\n break\\n return relations\",\n \"def respect_matching(self, network):\\n\\n # Iterate over the connected components of the network\\n\\n for component in nx.connected_component_subgraphs(network):\\n\\n # If the component has only two nodes it is respected by default\\n\\n if component.number_of_nodes() < 3:\\n continue\\n\\n # Partition the nodes into biparite sets\\n\\n left, right = nx.bipartite.sets(component)\\n\\n # As a convention, the left side is the one with fewer vertices.\\n # Swap left and right if right has fewer vertices.\\n\\n if len(left) > len(right):\\n left, right = right, left\\n\\n # The way we encode the constraint that a maximum cardinality\\n # matching of the symmetrization graph be respected is to force\\n # one edge incident to each vertex on the left side of each\\n # component be activated, while at most one edge incident to each\\n # vertex of the right side be activated. This will activate a\\n # maximum cardinality matching of the graph IFF the size of the\\n # maximum cardinality matching of each component is the number of\\n # vertices in the smaller biparite set of that component. Here we\\n # run a check to verify that this is the case.\\n\\n mcm_size = len(nx.max_weight_matching(component,\\n maxcardinality=True))\\n\\n assert mcm_size == len(left)\\n\\n # Iterate over vertices on the smaller biparite set and force\\n # exactly one of their incident edges to be activated\\n\\n for l in left:\\n table = self.activation_variables[l]\\n lits = [table[r] for r in table]\\n self.at_most_one(lits)\\n self.add_clause(lits)\\n\\n # Iterate over vertices on the larger bipartite set and force\\n # at most one of their incident edges to be activated\\n\\n for r in right:\\n table = self.activation_variables[r]\\n lits = [table[l] for l in table]\\n self.at_most_one(lits)\",\n \"def iter_clusters(letter_iter):\\n consonants = []\\n for letter in letter_iter:\\n if letter.is_vowell():\\n if consonants:\\n yield tuple(consonants)\\n consonants = []\\n yield tuple([letter])\\n else:\\n consonants.append(letter)\\n if consonants:\\n yield tuple(consonants)\",\n \"def extract_constraints(self, graphs):\\n for g in graphs:\\n fasta_id = g.graph['id']\\n gc_content = self._compute_gc_content(g)\\n cseq = self._extract_sequence_constraints(g,\\n self.importance_threshold_sequence_constraint,\\n self.min_size_connected_component_sequence_constraint)\\n struct = self. _extract_structure_constraints(g,\\n self.importance_threshold_structure_constraint,\\n self.min_size_connected_component_structure_constraint,\\n self.min_size_connected_component_unpaired_structure_constraint)\\n\\n yield struct, cseq, gc_content, fasta_id\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6238017","0.5909709","0.5907469","0.58362544","0.57939804","0.5792186","0.5703263","0.5681727","0.56771266","0.5671722","0.56632626","0.5611376","0.5602615","0.559068","0.5563447","0.5538029","0.55253816","0.55157125","0.5515107","0.5483767","0.5442139","0.54309833","0.5430769","0.54278564","0.5423296","0.54151136","0.5407725","0.5407581","0.5406938","0.5402561","0.5397461","0.53926426","0.53824335","0.5381416","0.53794754","0.5374309","0.5372052","0.5366919","0.5352852","0.53525025","0.5344149","0.5329437","0.5326537","0.5315885","0.5315222","0.5308315","0.53044295","0.53038365","0.53028774","0.5298619","0.52925766","0.5291122","0.5284724","0.5283136","0.5272274","0.52694774","0.5256571","0.52524865","0.52478266","0.52374387","0.5236209","0.52310145","0.5226244","0.5220079","0.52161956","0.52125955","0.5205594","0.5204671","0.51972264","0.5194836","0.51852006","0.51775956","0.5177482","0.5176216","0.51726776","0.51700974","0.5170074","0.51668423","0.51631683","0.5162848","0.516029","0.51586235","0.5153116","0.5151034","0.51427877","0.5136921","0.5133728","0.51301104","0.5127706","0.51273274","0.5114595","0.5114449","0.510217","0.5102117","0.51014155","0.5099447","0.5098696","0.5095946","0.5095511","0.5093602"],"string":"[\n \"0.6238017\",\n \"0.5909709\",\n \"0.5907469\",\n \"0.58362544\",\n \"0.57939804\",\n \"0.5792186\",\n \"0.5703263\",\n \"0.5681727\",\n \"0.56771266\",\n \"0.5671722\",\n \"0.56632626\",\n \"0.5611376\",\n \"0.5602615\",\n \"0.559068\",\n \"0.5563447\",\n \"0.5538029\",\n \"0.55253816\",\n \"0.55157125\",\n \"0.5515107\",\n \"0.5483767\",\n \"0.5442139\",\n \"0.54309833\",\n \"0.5430769\",\n \"0.54278564\",\n \"0.5423296\",\n \"0.54151136\",\n \"0.5407725\",\n \"0.5407581\",\n \"0.5406938\",\n \"0.5402561\",\n \"0.5397461\",\n \"0.53926426\",\n \"0.53824335\",\n \"0.5381416\",\n \"0.53794754\",\n \"0.5374309\",\n \"0.5372052\",\n \"0.5366919\",\n \"0.5352852\",\n \"0.53525025\",\n \"0.5344149\",\n \"0.5329437\",\n \"0.5326537\",\n \"0.5315885\",\n \"0.5315222\",\n \"0.5308315\",\n \"0.53044295\",\n \"0.53038365\",\n \"0.53028774\",\n \"0.5298619\",\n \"0.52925766\",\n \"0.5291122\",\n \"0.5284724\",\n \"0.5283136\",\n \"0.5272274\",\n \"0.52694774\",\n \"0.5256571\",\n \"0.52524865\",\n \"0.52478266\",\n \"0.52374387\",\n \"0.5236209\",\n \"0.52310145\",\n \"0.5226244\",\n \"0.5220079\",\n \"0.52161956\",\n \"0.52125955\",\n \"0.5205594\",\n \"0.5204671\",\n \"0.51972264\",\n \"0.5194836\",\n \"0.51852006\",\n \"0.51775956\",\n \"0.5177482\",\n \"0.5176216\",\n \"0.51726776\",\n \"0.51700974\",\n \"0.5170074\",\n \"0.51668423\",\n \"0.51631683\",\n \"0.5162848\",\n \"0.516029\",\n \"0.51586235\",\n \"0.5153116\",\n \"0.5151034\",\n \"0.51427877\",\n \"0.5136921\",\n \"0.5133728\",\n \"0.51301104\",\n \"0.5127706\",\n \"0.51273274\",\n \"0.5114595\",\n \"0.5114449\",\n \"0.510217\",\n \"0.5102117\",\n \"0.51014155\",\n \"0.5099447\",\n \"0.5098696\",\n \"0.5095946\",\n \"0.5095511\",\n \"0.5093602\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69560146"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20173,"cells":{"query":{"kind":"string","value":"Yields pairs of (source node, target node) for which all of their edges have the same type of relation."},"document":{"kind":"string","value":"def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v","def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target","def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))","def get_target_relations(\n self,\n source: Tuple[str, str],\n relation: Optional[str] = None,\n ) -> List[Relation]:\n return self.get_relations(source=source, target=None, relation=relation)","def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\"rel\"):\n s, o = int(s.id), int(o.id)\n yield {\"predicate\": p,\n \"subject\": s,\n \"subject_nodes\": list(self.get_descendants(s, triples)),\n \"object\": o,\n \"object_nodes\": list(self.get_descendants(o, triples)),\n }","def get_targets(\n self, source: Tuple[str, str], relation: Optional[str] = None\n ) -> List[Node]:\n return self.get_common_targets([source], relation)","def get_common_targets(\n self,\n sources: List[Tuple[str, str]],\n relation: str,\n ) -> List[Node]:\n rel_str = \":%s\" % relation if relation else \"\"\n parts = [\n \"({id: '%s'})-[%s]->(t)\" % (norm_id(*source), rel_str) for source in sources\n ]\n query = \"\"\"\n MATCH %s\n RETURN DISTINCT t\n \"\"\" % \",\".join(\n parts\n )\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\n return nodes","def directed(self):\n seen = {}\n for up, down in self:\n if (up is None) or (down is None):\n continue #omit unpaired bases\n if up > down:\n up, down = down, up\n seen[(up, down)] = True\n result = seen.keys()\n return Pairs(result)","def get_common_sources(\n self, targets: List[Tuple[str, str]], relation: str\n ) -> List[Node]:\n rel_str = \":%s\" % relation if relation else \"\"\n parts = [\n \"(s)-[%s]->({id: '%s'})\" % (rel_str, norm_id(*target)) for target in targets\n ]\n query = \"\"\"\n MATCH %s\n RETURN DISTINCT s\n \"\"\" % \",\".join(\n parts\n )\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\n return nodes","def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for neighbour in self.__graph_dict[node]:\n # Since all edges go both ways, we need only return one of them.\n if {neighbour, node} not in edges:\n edges.append({node, neighbour})\n yield (node, neighbour)","def get_source_relations(\n self,\n target: Tuple[str, str],\n relation: Optional[str] = None,\n ) -> List[Relation]:\n return self.get_relations(source=None, target=target, relation=relation)","def get_sources(self, target: Tuple[str, str], relation: str = None) -> List[Node]:\n return self.get_common_sources([target], relation)","def likely_pairs(self, k=2):\n for a in self.G.nodes():\n if not self.eligible_node(a):\n continue\n for b in neighbourhood(self.G, a, k):\n if not self.eligible_node(b):\n continue\n yield (a, b)","def get_all_pairs(G):\n # list all (start,dest) pairs between which the route must be computed\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\n\n # shuffle all elements in-place\n random.shuffle(pairs_list)\n\n # generate a set from the list\n pairs_set = set(pairs_list)\n\n return pairs_list, pairs_set","def get_relations(\n self,\n source: Optional[Tuple[str, str]] = None,\n target: Optional[Tuple[str, str]] = None,\n relation: Optional[str] = None,\n limit: Optional[int] = None,\n ) -> List[Relation]:\n if not source and not target:\n raise ValueError(\"source or target should be specified\")\n source = norm_id(*source) if source else None\n target = norm_id(*target) if target else None\n query = \"\"\"\n MATCH p=(%s)-[%s]->(%s)\n RETURN DISTINCT p\n %s\n \"\"\" % (\n \"{id: '%s'}\" % source if source else \"s\",\n \"\" if not relation else \":%s\" % relation,\n \"{id: '%s'}\" % target if target else \"t\",\n \"\" if not limit else \"LIMIT %s\" % limit,\n )\n rels = [self.neo4j_to_relation(res[0]) for res in self.query_tx(query)]\n return rels","def get_all_relations(\n self,\n node: Tuple[str, str],\n relation: Optional[str] = None,\n ) -> List[Relation]:\n source_rels = self.get_source_relations(target=node, relation=relation)\n target_rels = self.get_target_relations(source=node, relation=relation)\n all_rels = source_rels + target_rels\n return all_rels","def anchor_pairs(self):\n # TODO unit test for this method\n def _anchors(given_anchor):\n if given_anchor is not None:\n yield given_anchor\n else:\n yield from anchors.Anchor\n for src_anch in _anchors(self.orig_anchor):\n for dest_anch in _anchors(self.dest_anchor):\n yield (src_anch, dest_anch)","def generate_pairs(self, all_walks):\n logging.info(['edge_types before generate pairs', self.edge_types])\n\n pairs = []\n skip_window = self.config['win_size'] // 2\n for layer_id, e_type in enumerate(self.edge_types):\n walks = all_walks[e_type]\n for walk in tqdm.tqdm(walks):\n for i in range(len(walk)):\n for j in range(1, skip_window + 1):\n if i - j >= 0 and walk[i] != walk[i - j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i - j], *neg_nodes, layer_id))\n if i + j < len(walk) and walk[i] != walk[i + j]:\n neg_nodes = self.graph[e_type].sample_nodes(\n self.config['neg_num'])\n pairs.append(\n (walk[i], walk[i + j], *neg_nodes, layer_id))\n return pairs","def get_connection_directions(self, source: JuncNode, target: JuncNode) \\\n -> Tuple[JuncConnDirection, JuncConnDirection]:\n for node in source.all_nodes:\n for conn in node.get_connections():\n other_node = conn.other\n other_junc = self.get_junc_from_node(other_node)\n if other_junc == target:\n return source.side_of_node(node), target.side_of_node(other_node)\n raise Exception(f\"these juncs are not connected.\\n{source}\\n{target}\")","def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\n if include_metadata:\n return iter(\n [\n (e[\"source\"], e[\"target\"], _node_to_metadata(e[\"properties\"]))\n for e in (\n self._g.V()\n .outE()\n .project(\"target\", \"source\", \"properties\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .by(__.valueMap(True))\n .toList()\n )\n ]\n )\n return iter(\n [\n (e[\"source\"], e[\"target\"])\n for e in self._g.V()\n .outE()\n .project(\"target\", \"source\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .toList()\n ]\n )","def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\n if nbunch is None:\n nbunch = G\n else:\n nbunch = set(nbunch)\n\n directed = G.is_directed()\n if directed:\n iter_func = itertools.permutations\n else:\n iter_func = itertools.combinations\n\n all_pairs = {n: {} for n in nbunch}\n\n for u, v in iter_func(nbunch, 2):\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\n all_pairs[u][v] = k\n if not directed:\n all_pairs[v][u] = k\n\n return all_pairs","def _get_common_neighbour_node_pairs(self):\n node_pairs = []\n for node1 in self.graph.nodes():\n for node2 in self.graph.nodes():\n if node1 != node2:\n neighbour_count = self.neighbour_counts[(node1, node2)]\n if neighbour_count >= 1:\n node_pairs.append((node1, node2))\n return node_pairs","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\n\n n = len(aggr1)\n \n test_pairs = []\n for i in range(0, n):\n for j in range(0, n):\n if (aggr1[i] in table and aggr2[j] in table \n and (aggr1[i], aggr2[j]) in G.edges()\n ):\n test_pairs.append((aggr1[i], aggr2[j]))\n \n return test_pairs","def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def make_pairs(concepts):\n\tfor sub, obj in combinations(concepts, 2):\n\t\tif sub[1] != obj[1]:\n\t\t\tyield (sub, obj)","def _bayes_net_graph(nodes: List[str], edges: List[Tuple[str, str]]):\n sources_and_target = [[target] for target in range(len(nodes))]\n\n for source_node, target_node in edges:\n source = nodes.index(source_node)\n target = nodes.index(target_node)\n sources_and_target[target].insert(0, source)\n\n return [\n tuple(st for st in sts) if len(sts) > 1 else sts[0]\n for sts in sources_and_target\n ]","def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\n for downstream_key in self.downstream_deps:\n relationship = GraphRelationship(\n start_key=self.table_key,\n start_label=TableMetadata.TABLE_NODE_LABEL,\n end_label=TableMetadata.TABLE_NODE_LABEL,\n end_key=downstream_key,\n type=TableLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\n reverse_type=TableLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\n attributes={}\n )\n yield relationship","def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\n for downstream_key in self.downstream_deps:\n relationship = GraphRelationship(\n start_key=self.column_key,\n start_label=ColumnMetadata.COLUMN_NODE_LABEL,\n end_label=ColumnMetadata.COLUMN_NODE_LABEL,\n end_key=downstream_key,\n type=ColumnLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\n reverse_type=ColumnLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\n attributes={}\n )\n yield relationship","def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\n logger.debug(f\"comparing {node1},{node2}, traversed {traversed}\")\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\n #remove dummies\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\n #remove dummies\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\n logger.debug(f\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\")\n logger.debug(f\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\")\n if not nbrs1 or not nbrs2:\n if compare_two_nodes(G, node1, node2, ports_weight):\n match_pair[node1] = node2\n logger.debug(f\"no new neihbours, returning recursion {match_pair}\")\n return\n elif len(nbrs1)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n logger.debug(f\"skipping high fanout nets due to large computation, {node1} {nbrs1}\")\n traversed.append(node1)\n return\n elif len(nbrs2)> 10:\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n traversed.append(node2)\n logger.debug(f\"skipping high fanout nets due to large computation, {node2} {nbrs2}\")\n return\n\n if node1 == node2:\n if node1 in match_pair.keys() or node1 in match_pair.values():\n logger.debug(\"avoid existing pair wise symmetry\")\n return\n logger.debug(f\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\")\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\n ## TBD: filter based on primitive constraints\n ## Right now will try to figure out S/D paths\n if len(SD_nbrs) ==0:\n logger.debug(f\"No SD paths found to traverse\")\n match_pair[node1]=node1\n elif len(SD_nbrs) ==1:\n logger.debug(f\"traversing single S/D path {SD_nbrs}\")\n match_pair[node1]=node1\n traversed.append(node1)\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\n else:\n logger.debug(f\" multiple nodes diverging {SD_nbrs}\")\n logger.debug(f\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\")\n match_pair[node1]=node1\n traversed.append(node1)\n new_sp=sorted(set(SD_nbrs)-set(traversed))\n all_match_pairs_local={}\n for nbr1,nbr2 in combinations(new_sp, 2):\n logger.debug(f\"recursive pair call from single branch {nbr1} {nbr2}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n if new_pair:\n #new_pair[nbr1]=nbr2\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\n if len(all_match_pairs_local)==1:\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\n logger.debug(f\"found inline pair: {pprint.pformat(match_pair, indent=4)}\")\n else:\n for nbr1 in new_sp:\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\n logger.debug(f\"recursive single branch call from single branch {nbr1} {nbr1}\")\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif nbrs1 == nbrs2:\n logger.debug(f\"traversing converging branch\")\n match_pair[node1]=node2\n traversed+=[node1,node2]\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\n logger.debug(f\"all non traversed neighbours: {nbrs1}\")\n if len(nbrs1)==1:\n nbr1=nbr2=nbrs1[0]\n logger.debug(f\"keeping single converged branch inline {nbr1} {nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n else:\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\n logger.debug(f\"recursive call from converged branch {nbr1} {nbr2}\")\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\n new_pair={}\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\n if new_pair:\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\n logger.debug(f\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\")\n\n\n elif compare_two_nodes(G,node1,node2,ports_weight):\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\n match_pair[node1]=node2\n traversed+=[node1,node2]\n logger.debug(f\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\")\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\n if len(nbrs1)==0 or len(nbrs2)==0:\n logger.debug(f\"no new SD neihbours, returning recursion {match_pair}\")\n elif len(nbrs1) ==1 and len(nbrs2)==1:\n logger.debug(f\"traversing binary branch\")\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\n elif unique_match:\n logger.debug(f'traversing unique matches {unique_match}')\n match_pair[node1]=node2\n traversed+=[node1,node2]\n for nbr1,nbr2 in unique_match.items():\n logger.debug(f\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\")\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\n logger.debug(f\"setting new start points {node1} {node2}\")\n match_pair[node1]=node2\n if \"start_point\" in match_pair.keys():\n match_pair[\"start_point\"]+=[node1,node2]\n else:\n match_pair[\"start_point\"]=[node1,node2]\n else:\n match_pair = {}\n logger.debug(f\"end all traversal from binary branch {node1} {node2}\")\n\n else:\n match_pair = {}\n logger.debug(f\"end of recursion branch, matches {match_pair}\")","def multi_edge():\n from networkx.readwrite import json_graph\n import networkx as nx\n import autonetkit\n # returns a house graph\n data = {'directed': False,\n 'graph': [],\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 1},\n {'_ports': {'r2': 3, 'r4': 1},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r2': 4, 'r4': 3},\n 'raw_interfaces': {},\n 'source': 0,\n 'target': 3},\n {'_ports': {'r3': 3, 'r5': 2},\n 'raw_interfaces': {},\n 'source': 1,\n 'target': 4},\n {'_ports': {'r1': 1, 'r2': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 3, 'r2': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 3},\n {'_ports': {'r1': 2, 'r3': 1},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 4, 'r3': 4},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r1': 5, 'r3': 5},\n 'raw_interfaces': {},\n 'source': 2,\n 'target': 4},\n {'_ports': {'r2': 2, 'r3': 2},\n 'raw_interfaces': {},\n 'source': 3,\n 'target': 4}],\n 'multigraph': True,\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r4',\n 'label': 'r4',\n 'x': 675,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\n 'asn': 2,\n 'device_type': 'router',\n 'id': 'r5',\n 'label': 'r5',\n 'x': 675,\n 'y': 500},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r1',\n 'label': 'r1',\n 'x': 350,\n 'y': 400},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r2',\n 'label': 'r2',\n 'x': 500,\n 'y': 300},\n {'_ports': {0: {'category': 'physical', 'description': None},\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\n 'asn': 1,\n 'device_type': 'router',\n 'id': 'r3',\n 'label': 'r3',\n 'x': 500,\n 'y': 500}]}\n graph = json_graph.node_link_graph(data)\n anm = autonetkit.anm.NetworkModel()\n g_in = anm.add_overlay(\"input\")\n g_in._replace_graph(nx.MultiGraph(graph))\n # TODO: check if should build overlays here rather than clone in?\n g_phy = anm[\"phy\"]\n g_phy._replace_graph(graph)\n return anm","def possible(self):\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]","def indirect(stack):\n g = nx.Graph(stack)\n for group in nx.connected_components(g):\n yield from map(frozenset, combinations(group, 2))","def test_wires_to_edges_directed(self):\n g = nx.lollipop_graph(4, 1).to_directed()\n r = wires_to_edges(g)\n\n assert r == {\n 0: (0, 1),\n 1: (0, 2),\n 2: (0, 3),\n 3: (1, 0),\n 4: (1, 2),\n 5: (1, 3),\n 6: (2, 0),\n 7: (2, 1),\n 8: (2, 3),\n 9: (3, 0),\n 10: (3, 1),\n 11: (3, 2),\n 12: (3, 4),\n 13: (4, 3),\n }","def dfs_edges_generator(graph, source, reverse=...):\n ...","def get_links(self, node):\n\n # TODO: send help\n\n if not node.label:\n return []\n cls = node.__class__\n\n return [\n (\n e.__src_dst_assoc__,\n psqlgraph.Node.get_subclass_named(e.__dst_class__).label,\n )\n for e in psqlgraph.Edge._get_edges_with_src(cls.__name__)\n if hasattr(psqlgraph.Node.get_subclass_named(e.__dst_class__), \"project_id\")\n ] + [\n (\n e.__dst_src_assoc__,\n psqlgraph.Node.get_subclass_named(e.__src_class__).label,\n )\n for e in psqlgraph.Edge._get_edges_with_dst(cls.__name__)\n if hasattr(psqlgraph.Node.get_subclass_named(e.__src_class__), \"project_id\")\n ]","def create_relationships(self, source_nodes, target_nodes):\n source_nodes = (source_nodes,) if isinstance(source_nodes, Node) else source_nodes\n target_nodes = (target_nodes,) if isinstance(target_nodes, Node) else target_nodes\n for source_node in source_nodes:\n for target_node in target_nodes:\n self.create_relationship(source_node, target_node)","def connect_all(graph, nodeset):\n for element in nodeset:\n graph.add_node(element)\n for element1 in nodeset:\n for element2 in nodeset:\n if not element1 == element2:\n graph.add_edge(element1, element2)\n return graph","def relations(self):\n return set(self.triples()[\"relation\"])","def GetInOutRelationshipsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if rel in r[2]]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if rel in r[2]]\n res[gc.InputRelations][rel] = inRelations\n return res","def test_edges_to_wires_directed(self):\n g = nx.lollipop_graph(4, 1).to_directed()\n r = edges_to_wires(g)\n\n assert r == {\n (0, 1): 0,\n (0, 2): 1,\n (0, 3): 2,\n (1, 0): 3,\n (1, 2): 4,\n (1, 3): 5,\n (2, 0): 6,\n (2, 1): 7,\n (2, 3): 8,\n (3, 0): 9,\n (3, 1): 10,\n (3, 2): 11,\n (3, 4): 12,\n (4, 3): 13,\n }","def common_dependency_targets(graph1, graph2, n1, n2, node_attrib='label',\n edge_attrib='label'):\n n1_children = dependency_children(graph1, n1, edge_attrib=edge_attrib)\n n2_children = dependency_children(graph2, n2, edge_attrib=edge_attrib)\n n1_rels, n2_rels = defaultdict(list), defaultdict(list)\n\n for source_set, target_dict in ((n1_children, n1_rels), (n2_children, n2_rels)):\n for rel, target in source_set:\n target_dict[rel].append(target)\n\n common_rels = set(n1_rels) & set(n2_rels) # intersection\n common_deps = set()\n for rel in common_rels:\n for n1_target in n1_rels[rel]:\n n1_target_word = graph1.node[n1_target][node_attrib]\n for n2_target in n2_rels[rel]:\n n2_target_word = graph2.node[n2_target][node_attrib]\n if n1_target_word == n2_target_word:\n common_deps.add( (n1_target, n2_target) )\n return common_deps","def process(self, source: Generator, sink: Sink) -> None:\n for rec in source:\n if rec:\n log.debug(\"length of rec\", len(rec), \"rec\", rec)\n if len(rec) == 4: # infer an edge record\n write_edge = True\n if \"subject_category\" in self.edge_filters:\n if rec[0] in self._seen_nodes:\n write_edge = True\n else:\n write_edge = False\n if \"object_category\" in self.edge_filters:\n if rec[1] in self._seen_nodes:\n if \"subject_category\" in self.edge_filters:\n if write_edge:\n write_edge = True\n else:\n write_edge = True\n else:\n write_edge = False\n if write_edge:\n if self.inspector:\n self.inspector(GraphEntityType.EDGE, rec)\n sink.write_edge(rec[-1])\n else: # infer a node record\n if \"category\" in self.node_filters:\n self._seen_nodes.add(rec[0])\n if self.inspector:\n self.inspector(GraphEntityType.NODE, rec)\n # last element of rec is the node properties\n sink.write_node(rec[-1])","def connections( self, cls = None ):\n scene = self.scene()\n if ( not scene ):\n return []\n \n if ( not cls ):\n cls = XNodeConnection\n \n output = []\n for item in scene.items():\n if ( not isinstance(item, cls) ):\n continue\n \n if ( item.inputNode() == self or item.outputNode() == self ):\n output.append(item)\n \n return output","def edge_sig(T, source=[], target=[], type_='out'):\n case_cnt = sum([v[0] for v in T['start'].values()])\n S = dict()\n for a_i in source:\n S[a_i] = dict()\n target_ = T if type_ != 'out' else T[a_i]\n for a_j in target_:\n if (a_i == a_j) | (a_j not in target): continue\n if type_ != 'out':\n if a_i in T[a_j]: S[a_i][a_j] = T[a_j][a_i][1] / case_cnt\n else: S[a_i][a_j] = T[a_i][a_j][1] / case_cnt\n return S","def graph_generation(nodes: np.ndarray, edges: np.ndarray):\n result_nodes = []\n result_edges = []\n\n last_index = nodes[-1, 0]\n\n done = False\n # print(nodes)\n for p in range(nodes.shape[0]):\n for q in range(nodes.shape[0]):\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\n nodes[q, nodes.shape[1] - 2]:\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\n np.append(nodes[q, nodes.shape[1] - 1],\n np.append(nodes[p, 0],\n nodes[q, 0]))))\n if not done:\n result_nodes = [tmp_node]\n done = True\n else:\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\n\n result_nodes = result_nodes[np.argsort(\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\n\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\n # print(result_nodes)\n\n done = False\n for e in range(edges.shape[0]):\n for f in range(edges.shape[0]):\n for p in range(result_nodes.shape[0]):\n for q in range(result_nodes.shape[0]):\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\n result_nodes[p, -1] == result_nodes[q, -1]) \\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\n result_nodes[p, -2] == result_nodes[q, -2]):\n if not done:\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\n done = True\n else:\n result_edges = np.concatenate(\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\n # print(edges)\n\n # print(result_edges)\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\n # print(unique_result_edges)\n final_edges = []\n for k in range(len(unique_result_edges)):\n for j in range(result_edges.shape[0]):\n if str(result_edges[j]) == unique_result_edges[k]:\n if k == 0:\n final_edges = result_edges[j]\n break\n else:\n final_edges = np.concatenate((final_edges, result_edges[j]))\n break\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\n # print(final_edges.shape[0])\n done = False\n edge_to_remove = []\n for j in range(final_edges.shape[0]):\n for k in range(j + 1, final_edges.shape[0]):\n if final_edges[j, 1] == final_edges[k, 0]:\n if not done:\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\n done = True\n else:\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\n # print(edge_to_remove)\n\n idx_to_remove = []\n done = False\n for j in range(edge_to_remove.shape[0]):\n for k in range(final_edges.shape[0]):\n if list(edge_to_remove[j]) == list(final_edges[k]):\n if not done:\n idx_to_remove = k\n done = True\n else:\n idx_to_remove = np.append(idx_to_remove, k)\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\n # print(final_edges)\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\n # print(result_nodes)\n return result_nodes, final_edges","def getAllEdges(mutations):\n\tallEdges = []\n\tfor mutation in mutations: \n\t\tprint mutation\n\t\tfor mutation2 in mutations:\n\t\t\tif not (mutation == mutation2): # No edges connecting to themselves.\n\t\t\t\ttmp = []\n\t\t\t\ttmp.append(mutation)\n\t\t\t\ttmp.append(mutation2)\n\t\t\t\tallEdges.append(tmp)\n\treturn allEdges","def relations_from(self, start_node):","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def test_sources():\n g = Graph(from_list=[\n (1, 3, 1),\n (2, 4, 1),\n (2, 5, 1),\n (3, 5, 1),\n (4, 6, 1),\n (5, 6, 1),\n ])\n g.add_node(7)\n s = g.sources(5)\n e = {1, 2, 3}\n assert s == e\n\n s2 = g.sources(1)\n e2 = set()\n assert s2 == e2, s2\n\n s3 = g.sources(6)\n e3 = {1, 2, 3, 4, 5}\n assert s3 == e3\n\n s4 = g.sources(7)\n e4 = set()\n assert s4 == e4","def relations_to(self, end_node):","def permuteEdgeTypes(self):\n\t\tpermuted_graph = copy.copy(self)\n\t\t# swap about half the edges\n\t\ti = len(self.graph)/2\n\t\twhile i > 0:\n\t\t\t# swap \n\t\t\tsourceA, targetA = random.choice(permuted_graph.graph.keys())\n\t\t\tiTypeA, emA = permuted_graph.graph[(sourceA, targetA)]\n\t\t\tsourceB, targetB = random.choice(permuted_graph.graph.keys())\n\t\t\tiTypeB, emB = permuted_graph.graph[(sourceB, targetB)]\n\t\t\tpermuted_graph.graph[(sourceA, targetA)] = (iTypeB, emB)\n\t\t\tpermuted_graph.graph[(sourceB, targetB)] = (iTypeA, emA)\n\n\t\t\ti -= 1\n\n\t\t# return a new graph object\t\t\n\t\treturn permuted_graph","def pairs_of_vertices(self):\n pairs_of_vertices = []\n for vertice in self.list_of_vertices:\n for edge in vertice.edges_list:\n if non_oriented:\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n if not non_oriented:\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\n pairs_of_vertices.append((vertice, edge.linked[1]))\n return pairs_of_vertices","def get_cross_synset_pairs(src_synset: Synset, dst_synset: Synset) -> list:\n # Remove phrasal expressions from the literals\n src_literals = remove_phrases(src_synset.literals)\n dst_literals = remove_phrases(dst_synset.literals)\n\n return unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in src_literals for w2 in dst_literals])","def edge_generator(n1_nodes, n2_nodes, p_in, p_out):\n\n e_gen = lambda n1,n2,p: [e for e in [x for x in itertools.product(n1,n2) if x[0]!=x[1]] if random.random()<p]\n\n between_es = e_gen(n1_nodes, n2_nodes, p_out)\n in_n1 = e_gen(n1_nodes, n1_nodes, p_in)\n in_n2 = e_gen(n2_nodes, n2_nodes, p_in)\n\n return between_es + in_n1 + in_n2","def get_contradictory_pairs(graph):\n for u, v in _iter_pairs(graph):\n if pair_has_contradiction(graph, u, v):\n yield u, v","def iter_links(self):\n for site in self.iter_sites():\n for u in range(self.dim):\n yield tuple(list(site) + [u])","def _get_connection(\n source: NodeInstance, target: Optional[NodeInstance], seen: dict\n ) -> None:\n if source is target:\n return None\n for rel in source.get_requirements(target):\n if id(rel) not in seen:\n seen[id(rel)] = rel","def both(self, from_to, *edge_classes):\n records = self.client.command('SELECT both({0}) FROM {1}'\n .format(','.join(self.coerce_class_names(edge_classes))\n , self.coerce_class_names(from_to)))\n return [self.get_vertex(v) for v in records[0].oRecordData['both']] \\\n if records else []","def edges(self):\n return [(a, b) for a in self._consequences_of\n for b in self._consequences_of[a]]","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def serialize_nx_node_to_triples(g, key, node=None):\n\n node = node or g and g.node.get(key) # <curie/key> # ... precis\n\n yield (key, 'a', node.get('type')) # <> a <type>\n\n for attr,value in node.items():\n yield (key, attr, value)\n\n # MultiDiGraph\n for edge in g.edge.get(key):\n # multivalue edges\n # <> linkTo _:ReifiedEdge\n\n # = BNode(), UUID\n # = edge_url\n s = '#e/'.join((key,uuid,))\n yield (s, 'a', 'edgetype')\n yield (s, 'linksFrom', key)\n yield (s, 'linksTo', edge)\n\n for attr, value in edge.items():\n yield (s, attr, edge.get(attr))\n # _:ReifiedEdge attr[n] value[n]","def upstream_nodes_of_type(self, target_node_name, operation_type):\n assert target_node_name in self.node_map\n nodes = self.nodes_of_type(operation_type)\n nodes = [node for node in nodes if has_path(self.G2, node, target_node_name)]\n return set(nodes)","def generation_next(prev_gen):\n next_gen = []\n\n # Iter through list of graphs\n for original_graph in prev_gen:\n # Select edges to nodes which are at distance 2\n select_edges = dist2_nodepairs(original_graph)\n\n # Go through the list of possible selected edges and add one\n for test_edge in select_edges:\n test_graph = original_graph.copy()\n test_graph.add_edge(*test_edge)\n if (not graph_exists(test_graph, next_gen)) \\\n and check_test_graph(test_graph):\n next_gen.append(test_graph)\n\n return next_gen","def _pipe(self, nodes):\n # Collect all vertices, handling special named parameter targets separately.\n vertices = []\n for item in nodes:\n if isinstance(item, EdgeDef):\n vertices.append(EdgeDef(self._store_node(item.node), item.param))\n else:\n vertices.append(EdgeDef(self._store_node(item), None))\n\n for i in range(1, len(vertices)):\n source = vertices[i - 1]\n target = vertices[i]\n\n self._downstream[source.node].append(target)\n self._upstream[target.node].append(EdgeDef(source.node, target.param))","def clean_edges(self):\n for from_node in self.all_nodes():\n for to_node in self.all_nodes():\n if from_node == to_node:\n continue\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\n if len(dup) > 1:\n for d in dup[1:]:\n self.edges.remove(d)","def junctions(self):\n for node_name in self._junctions:\n yield node_name, self._data[node_name]","def _get_and_create_relation_objects(self, root_node):\n relations = []\n\n for relation in root_node.iterdescendants(\"TLINK\"):\n lid = relation.get(\"lid\")\n\n # Get relation type as a string\n relation_type = relation.get(\"relType\")\n\n # Get relation_type_id\n relation_type_id = RelationType.get_id(relation_type)\n\n if not relation.get(\"timeID\") and not relation.get(\"relatedToTime\"):\n # This is event-event\n source_eiid = relation.get(\"eventInstanceID\")\n target_eiid = relation.get(\"relatedToEventInstance\")\n\n # Find source event\n source_obj = self.find_event_by_eiid(self.events, source_eiid)\n # Find target event\n target_obj = self.find_event_by_eiid(self.events, target_eiid)\n\n else:\n # This must be event-timex or timex-event or timex-timex\n target_tid = relation.get(\"relatedToTime\")\n target_eiid = relation.get(\"relatedToEventInstance\")\n\n source_tid = relation.get(\"timeID\")\n source_eiid = relation.get(\"eventInstanceID\")\n\n\n if source_tid and target_eiid:\n # timex-event\n source_obj = self.find_timex_by_tid(source_tid)\n target_obj = self.find_event_by_eiid(self.events, target_eiid)\n elif source_eiid and target_tid:\n # event-timex\n source_obj = self.find_event_by_eiid(self.events, source_eiid)\n target_obj = self.find_timex_by_tid(target_tid)\n elif source_tid and target_tid:\n # timex-timex\n source_obj = self.find_timex_by_tid(source_tid)\n target_obj = self.find_timex_by_tid(target_tid)\n\n relation_obj = Relation(lid, self.text_obj, source_obj, target_obj, relation_type_id)\n\n # So we don't run into problems with helper.output\n if relation_obj.is_timex_timex(): relation_obj.predicted_class = relation_type_id\n\n # There are sometimes duplicates which we do not want to have\n if relation_obj not in relations:\n relations.append(relation_obj)\n\n return relations","def _append_source_and_target(self, graph):\n graph.add_node( \"source\" )\n graph.add_node( \"target\" )\n \n for leave in (n for n,d in graph.out_degree_iter() if d==0):\n if leave is not \"source\" and leave is not \"target\":\n graph.add_edge( leave, \"target\" )\n \n for root in (n for n,d in graph.in_degree_iter() if d==0):\n if root is not \"source\" and root is not \"target\": \n graph.add_edge( \"source\", root )","def node_targets(self, node):\r\n node = self.coalesce_node(node)\r\n nodes =[conn[1] for conn in self.connections if conn[0] == node]\r\n return nodes","def step(nodes, outputs, edges):\n flowed = []\n for node_name in nodes.copy():\n if node_name in flowed:\n continue\n if len(nodes[node_name]) == 2:\n if node_name in flowed:\n continue\n node = [int(value) for value in nodes[node_name]]\n low_value, high_value = min(node), max(node)\n low_flow, high_flow = edges[node_name] \n low_dictionary, low_node_name = low_flow\n high_dictionary, high_node_name = high_flow\n low_node = low_dictionary.get(low_node_name, tuple())\n high_node = high_dictionary.get(high_node_name, tuple())\n low_dictionary[low_node_name] = low_node + (str(low_value),)\n high_dictionary[high_node_name] = high_node + (str(high_value),)\n nodes[node_name] = tuple()\n if low_dictionary is nodes:\n flowed.append(low_node_name)\n if high_dictionary is nodes:\n flowed.append(high_node_name)\n return nodes, outputs, edges","def adjacentTo()\r\n\r\n def fitsWith(self, other):\r\n # TODO: Can use list comprehesion??\r\n for i, selfEdge in enumerate(self.getEdges()):\r\n for j, otherEdge in other.getEdges():\r\n if selfEdge.fitsWith(otherEdge):\r\n return i, j\r\n return False # made it here, so no edge fits together\r","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def generate_networkx_graphs(raw_graphs):\n\n source_graphs = [source_from_raw(raw) for raw in raw_graphs]\n target_graphs = [target_from_raw(raw) for raw in raw_graphs]\n\n return source_graphs, target_graphs","def test_outgoing_edge_traversals(self):\r\n e1 = TestEdge.create(self.v1, self.v2, numbers=12)\r\n e2 = TestEdge.create(self.v1, self.v3, numbers=13)\r\n e3 = OtherTestEdge.create(self.v2, self.v3, numbers=14)\r\n\r\n results = self.v2.outE()\r\n assert len(results) == 1\r\n assert e3 in results\r\n\r\n results = self.v2.outE(types=[TestEdge])\r\n assert len(results) == 0","def neighbours(assignment): \n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\n new_assign = list(assignment)\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\n yield tuple(new_assign)","def test_relationship_edges(self):\n path = os.path.join(get_file_dir(), 'data', 'GO_edges_relationship.json')\n with open(path, 'rt') as json_file:\n json_files = []\n for data in json_file:\n json_files.append(json.loads(data))\n for entry in json_files:\n if entry[\"id\"] == \"GO:0000332__GO:0003720__part_of\":\n self.assertEqual(entry[\"from\"], \"GO_term/GO:0000332\")\n self.assertEqual(entry[\"to\"], \"GO_term/GO:0003720\")\n self.assertEqual(entry[\"relationship_type\"], \"part_of\")\n if entry[\"from\"] == \"GO_term/GO:0000335\":\n self.assertEqual(entry[\"id\"], \"GO:0000335__GO:0006313__negatively_regulates\")\n self.assertEqual(entry[\"to\"], \"GO_term/GO:0006313\")\n self.assertEqual(entry[\"relationship_type\"], \"negatively_regulates\")","def match_nodes(source_node, target_node):\n\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\n cmds.xform(target_node, ws=True, t=node_position)\n cmds.xform(target_node, ws=True, ro=node_rotation)","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def mut_space(graph: nx.Graph) -> t.Iterator[t.Tuple[int, t.List[str]]]:\n genes = get_attr(graph, 'gene')\n xs = sorted(chain.from_iterable(((g.P1, g.A1), (g.P2, g.A2)) for g in genes))\n return ((g, sorted(set(x[1] for x in gg))) for g, gg in groupby(xs, key=op.itemgetter(0)))","def adjacent(self):\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\n result.remove(self)\n return result","def edges(self):\n return self.dovetails + self.containments + self.internals","def getMultipleEdgesBetweenSameNodesGraph(self):\n return create_quadEdgeCross(self)","def _iterate_protocol(self):\n # we can't fuzz if we don't have at least one target and one request.\n if not self.targets:\n raise sex.SullyRuntimeError(\"No targets specified in session\")\n\n if not self.edges_from(self.root.id):\n raise sex.SullyRuntimeError(\"No requests specified in session\")\n\n self._reset_fuzz_state()\n\n for x in self._iterate_protocol_recursive(this_node=self.root, path=[]):\n yield x","def test_wires_to_edges(self):\n g = nx.lollipop_graph(4, 1)\n r = wires_to_edges(g)\n\n assert r == {0: (0, 1), 1: (0, 2), 2: (0, 3), 3: (1, 2), 4: (1, 3), 5: (2, 3), 6: (3, 4)}","def _find_paired_nodes(self, graph):\n paired_list = []\n for line in nx.generate_edgelist(graph):\n if ('basepair' in line):\n if not (int(line.split(' ')[0]) in paired_list):\n paired_list.append(int(line.split(' ')[0]))\n if not (int(line.split(' ')[1]) in paired_list):\n paired_list.append(int(line.split(' ')[1]))\n return paired_list","def get_relationships_by_genus_type_for_peers_on_date(self, source_id, destination_id, relationship_genus_type, from_, to):\n raise errors.Unimplemented()","def test_multiple_edge_traversal_with_type_filtering(self):\r\n v = TestModel.create(count=1, text='Test1')\r\n\r\n v1 = TestModel.create()\r\n TestEdge.create(v, v1)\r\n\r\n v2 = TestModel.create()\r\n OtherTestEdge.create(v, v2)\r\n\r\n v3 = TestModel.create()\r\n YetAnotherTestEdge.create(v, v3)\r\n\r\n v4 = OtherTestModel.create()\r\n TestEdge.create(v, v4)\r\n\r\n v5 = OtherTestModel.create()\r\n OtherTestEdge.create(v, v5)\r\n\r\n v6 = OtherTestModel.create()\r\n YetAnotherTestEdge.create(v, v6)\r\n\r\n assert len(v.outV()) == 6\r\n\r\n assert len(v.outV(TestEdge, OtherTestEdge)) == 4\r\n assert len(v.outV(TestEdge, OtherTestEdge, types=[TestModel])) == 2","def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v","def get_sharp_relations_for_sets(follows, set_1, set_2):\n for item_1 in set_1:\n for item_2 in set_2:\n if not get_sharp_relation(follows, item_1, item_2):\n return False\n return True","def dfs_labeled_edges_generator(graph, source, reverse=..., has_reverse_edge=..., has_nontree_edge=..., return_labels=...): # -> tuple[Unknown, Unknown]:\n ...","def edges(self, and_weights=False):\n\n # Keep track of yielded so as not to yield (1, 2) AND (2, 1), since\n # they are the same edge using this graph representation\n yielded = set()\n \n # Iterate over the vertices in the graph\n for vertex, neighbors in self._edges.items():\n for neighbor in neighbors:\n \n # Use a frozen set to keep track of tuples without caring\n # about the order of the elements\n to_yield = frozenset((vertex, neighbor))\n \n # Seen it before, so do not yield it again\n if to_yield in yielded:\n continue\n # Never seen before, add it\n else:\n yielded.add(to_yield)\n\n # Yield edge and weights if the user requested it\n if and_weights:\n yield (vertex, neighbor), self._weights[to_yield]\n else:\n yield (vertex, neighbor)","def get_all_relations(graph, u, v):\n return {\n data[RELATION]\n for data in graph.edge[u][v].values()\n }","def edges(self, node):\n nID = self.n2ID[node]\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]","def edge_mapping(self):\n ...","def GetInOutRelationsForList(self, G, node, relations=[]):\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\n if len(relations) > 0:\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\n \n for rel in relations:\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.OutgoingRelations][rel] = outRelations\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\n res[gc.InputRelations][rel] = inRelations\n return res","def find_relationships(self, fig1, fig2):\r\n \r\n rels = []\r\n \r\n # relationship based on # of objects\r\n if len(fig1) == len(fig2):\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\r\n else:\r\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\r\n \r\n for obj, attrs in fig1.items():\r\n if not obj in fig2:\r\n # object has been removed in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\r\n continue\r\n \r\n for obj in fig2:\r\n if not obj in fig1:\r\n # object is only present in fig2\r\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\r\n continue\r\n \r\n for attr in fig2[obj]:\r\n rel = {'obj': obj, 'attr': attr}\r\n \r\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\r\n rel['type'] = 'match'\r\n else:\r\n partial_match = False\r\n for subvalue in fig2[obj][attr]:\r\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\r\n partial_match = True\r\n \r\n if partial_match:\r\n rel['type'] = 'partial'\r\n else:\r\n rel['type'] = 'mismatch'\r\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\r\n rel['new_values'] = ','.join(fig2[obj][attr])\r\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\r\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\r\n del rel['old_values']\r\n del rel['new_values']\r\n \r\n rels.append(rel)\r\n \r\n return rels","def find_type_tuples_relationship(self, type_tuples, baseline_dict=None, ignore_sqns=False, force_deep_scan=False, max_similarity=0.8):\n\n # if self.VERBOSE:\n # print u'Find type tuples relationships: %s' % (u', '.join(map(unicode, type_tuples.keys())))\n\n i_count = 0\n types_suggested_relations = defaultdict(list)\n \"\"\"@type: dict of (ProductType, list[ProductType.Relation])\"\"\"\n\n type_tuples_for_deep_scan = dict(type_tuples)\n dict_types = baseline_dict or self.get_type_tuples(meaningful_only=True)\n if ignore_sqns:\n # Optimize lookup data set - do not iterate for known types, just map as identical\n for t in type_tuples:\n if t in dict_types:\n # Must always find identical relation\n rel = self.compare_types(t, t)\n types_suggested_relations[t].append(rel)\n if force_deep_scan:\n del type_tuples_for_deep_scan[t]\n\n if not force_deep_scan and types_suggested_relations:\n # If identical types have been found deep scan is not required\n type_tuples_for_deep_scan.clear()\n # if self.VERBOSE: print \"Identical type 's been found, skip deep scan\"\n\n for t1, t2 in itertools.product(type_tuples_for_deep_scan.viewitems(), dict_types.viewitems()):\n type_input = t1[0]\n \"\"\"@type: ProductType\"\"\"\n type_dict = t2[0]\n \"\"\"@type: ProductType\"\"\"\n\n rel = self.compare_types(type_input, type_dict, max_similarity)\n\n if rel:\n types_suggested_relations[type_input].append(rel)\n\n i_count += 1\n if self.VERBOSE and i_count % 10000 == 0: print(u'.', end='')\n if self.VERBOSE and i_count % 1000000 == 0: print(i_count)\n if self.VERBOSE and i_count >= 10000:\n print()\n # print u'Suggested %d types' % len(types_suggested_relations)\n\n return types_suggested_relations","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def test_edges_to_wires(self):\n g = nx.lollipop_graph(4, 1)\n r = edges_to_wires(g)\n\n assert r == {(0, 1): 0, (0, 2): 1, (0, 3): 2, (1, 2): 3, (1, 3): 4, (2, 3): 5, (3, 4): 6}"],"string":"[\n \"def _iter_pairs(graph):\\n for u, v in set(graph.edges_iter()):\\n yield u, v\",\n \"def iteredges(self):\\n for source, targets in self.successors.items():\\n for target in targets:\\n yield source, target\",\n \"def all_pairs(self):\\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))\",\n \"def get_target_relations(\\n self,\\n source: Tuple[str, str],\\n relation: Optional[str] = None,\\n ) -> List[Relation]:\\n return self.get_relations(source=source, target=None, relation=relation)\",\n \"def get_relations(self):\\n triples = list(self.get_triples())\\n\\n for s, p, o in triples:\\n if not p.startswith(\\\"rel\\\"):\\n s, o = int(s.id), int(o.id)\\n yield {\\\"predicate\\\": p,\\n \\\"subject\\\": s,\\n \\\"subject_nodes\\\": list(self.get_descendants(s, triples)),\\n \\\"object\\\": o,\\n \\\"object_nodes\\\": list(self.get_descendants(o, triples)),\\n }\",\n \"def get_targets(\\n self, source: Tuple[str, str], relation: Optional[str] = None\\n ) -> List[Node]:\\n return self.get_common_targets([source], relation)\",\n \"def get_common_targets(\\n self,\\n sources: List[Tuple[str, str]],\\n relation: str,\\n ) -> List[Node]:\\n rel_str = \\\":%s\\\" % relation if relation else \\\"\\\"\\n parts = [\\n \\\"({id: '%s'})-[%s]->(t)\\\" % (norm_id(*source), rel_str) for source in sources\\n ]\\n query = \\\"\\\"\\\"\\n MATCH %s\\n RETURN DISTINCT t\\n \\\"\\\"\\\" % \\\",\\\".join(\\n parts\\n )\\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\\n return nodes\",\n \"def directed(self):\\n seen = {}\\n for up, down in self:\\n if (up is None) or (down is None):\\n continue #omit unpaired bases\\n if up > down:\\n up, down = down, up\\n seen[(up, down)] = True\\n result = seen.keys()\\n return Pairs(result)\",\n \"def get_common_sources(\\n self, targets: List[Tuple[str, str]], relation: str\\n ) -> List[Node]:\\n rel_str = \\\":%s\\\" % relation if relation else \\\"\\\"\\n parts = [\\n \\\"(s)-[%s]->({id: '%s'})\\\" % (rel_str, norm_id(*target)) for target in targets\\n ]\\n query = \\\"\\\"\\\"\\n MATCH %s\\n RETURN DISTINCT s\\n \\\"\\\"\\\" % \\\",\\\".join(\\n parts\\n )\\n nodes = [self.neo4j_to_node(res[0]) for res in self.query_tx(query)]\\n return nodes\",\n \"def edges(self) -> Iterable[Tuple[Node]]:\\n edges = []\\n for node in self.__graph_dict.keys():\\n for neighbour in self.__graph_dict[node]:\\n # Since all edges go both ways, we need only return one of them.\\n if {neighbour, node} not in edges:\\n edges.append({node, neighbour})\\n yield (node, neighbour)\",\n \"def get_source_relations(\\n self,\\n target: Tuple[str, str],\\n relation: Optional[str] = None,\\n ) -> List[Relation]:\\n return self.get_relations(source=None, target=target, relation=relation)\",\n \"def get_sources(self, target: Tuple[str, str], relation: str = None) -> List[Node]:\\n return self.get_common_sources([target], relation)\",\n \"def likely_pairs(self, k=2):\\n for a in self.G.nodes():\\n if not self.eligible_node(a):\\n continue\\n for b in neighbourhood(self.G, a, k):\\n if not self.eligible_node(b):\\n continue\\n yield (a, b)\",\n \"def get_all_pairs(G):\\n # list all (start,dest) pairs between which the route must be computed\\n pairs_list = [(start, dest) for dest in G.nodes for start in G.nodes]\\n\\n # shuffle all elements in-place\\n random.shuffle(pairs_list)\\n\\n # generate a set from the list\\n pairs_set = set(pairs_list)\\n\\n return pairs_list, pairs_set\",\n \"def get_relations(\\n self,\\n source: Optional[Tuple[str, str]] = None,\\n target: Optional[Tuple[str, str]] = None,\\n relation: Optional[str] = None,\\n limit: Optional[int] = None,\\n ) -> List[Relation]:\\n if not source and not target:\\n raise ValueError(\\\"source or target should be specified\\\")\\n source = norm_id(*source) if source else None\\n target = norm_id(*target) if target else None\\n query = \\\"\\\"\\\"\\n MATCH p=(%s)-[%s]->(%s)\\n RETURN DISTINCT p\\n %s\\n \\\"\\\"\\\" % (\\n \\\"{id: '%s'}\\\" % source if source else \\\"s\\\",\\n \\\"\\\" if not relation else \\\":%s\\\" % relation,\\n \\\"{id: '%s'}\\\" % target if target else \\\"t\\\",\\n \\\"\\\" if not limit else \\\"LIMIT %s\\\" % limit,\\n )\\n rels = [self.neo4j_to_relation(res[0]) for res in self.query_tx(query)]\\n return rels\",\n \"def get_all_relations(\\n self,\\n node: Tuple[str, str],\\n relation: Optional[str] = None,\\n ) -> List[Relation]:\\n source_rels = self.get_source_relations(target=node, relation=relation)\\n target_rels = self.get_target_relations(source=node, relation=relation)\\n all_rels = source_rels + target_rels\\n return all_rels\",\n \"def anchor_pairs(self):\\n # TODO unit test for this method\\n def _anchors(given_anchor):\\n if given_anchor is not None:\\n yield given_anchor\\n else:\\n yield from anchors.Anchor\\n for src_anch in _anchors(self.orig_anchor):\\n for dest_anch in _anchors(self.dest_anchor):\\n yield (src_anch, dest_anch)\",\n \"def generate_pairs(self, all_walks):\\n logging.info(['edge_types before generate pairs', self.edge_types])\\n\\n pairs = []\\n skip_window = self.config['win_size'] // 2\\n for layer_id, e_type in enumerate(self.edge_types):\\n walks = all_walks[e_type]\\n for walk in tqdm.tqdm(walks):\\n for i in range(len(walk)):\\n for j in range(1, skip_window + 1):\\n if i - j >= 0 and walk[i] != walk[i - j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i - j], *neg_nodes, layer_id))\\n if i + j < len(walk) and walk[i] != walk[i + j]:\\n neg_nodes = self.graph[e_type].sample_nodes(\\n self.config['neg_num'])\\n pairs.append(\\n (walk[i], walk[i + j], *neg_nodes, layer_id))\\n return pairs\",\n \"def get_connection_directions(self, source: JuncNode, target: JuncNode) \\\\\\n -> Tuple[JuncConnDirection, JuncConnDirection]:\\n for node in source.all_nodes:\\n for conn in node.get_connections():\\n other_node = conn.other\\n other_junc = self.get_junc_from_node(other_node)\\n if other_junc == target:\\n return source.side_of_node(node), target.side_of_node(other_node)\\n raise Exception(f\\\"these juncs are not connected.\\\\n{source}\\\\n{target}\\\")\",\n \"def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\\n if include_metadata:\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"], _node_to_metadata(e[\\\"properties\\\"]))\\n for e in (\\n self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\", \\\"properties\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .by(__.valueMap(True))\\n .toList()\\n )\\n ]\\n )\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"])\\n for e in self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .toList()\\n ]\\n )\",\n \"def all_pairs_node_connectivity(G, nbunch=None, cutoff=None):\\n if nbunch is None:\\n nbunch = G\\n else:\\n nbunch = set(nbunch)\\n\\n directed = G.is_directed()\\n if directed:\\n iter_func = itertools.permutations\\n else:\\n iter_func = itertools.combinations\\n\\n all_pairs = {n: {} for n in nbunch}\\n\\n for u, v in iter_func(nbunch, 2):\\n k = local_node_connectivity(G, u, v, cutoff=cutoff)\\n all_pairs[u][v] = k\\n if not directed:\\n all_pairs[v][u] = k\\n\\n return all_pairs\",\n \"def _get_common_neighbour_node_pairs(self):\\n node_pairs = []\\n for node1 in self.graph.nodes():\\n for node2 in self.graph.nodes():\\n if node1 != node2:\\n neighbour_count = self.neighbour_counts[(node1, node2)]\\n if neighbour_count >= 1:\\n node_pairs.append((node1, node2))\\n return node_pairs\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def testPairs(G, aggr_nodes, prefix1='2_0', prefix2='2_1', table=None):\\n aggr1 = [x for x in aggr_nodes[1:80:8] if prefix1 in x]\\n aggr2 = [x for x in aggr_nodes[0:80:8] if prefix2 in x]\\n\\n n = len(aggr1)\\n \\n test_pairs = []\\n for i in range(0, n):\\n for j in range(0, n):\\n if (aggr1[i] in table and aggr2[j] in table \\n and (aggr1[i], aggr2[j]) in G.edges()\\n ):\\n test_pairs.append((aggr1[i], aggr2[j]))\\n \\n return test_pairs\",\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def make_pairs(concepts):\\n\\tfor sub, obj in combinations(concepts, 2):\\n\\t\\tif sub[1] != obj[1]:\\n\\t\\t\\tyield (sub, obj)\",\n \"def _bayes_net_graph(nodes: List[str], edges: List[Tuple[str, str]]):\\n sources_and_target = [[target] for target in range(len(nodes))]\\n\\n for source_node, target_node in edges:\\n source = nodes.index(source_node)\\n target = nodes.index(target_node)\\n sources_and_target[target].insert(0, source)\\n\\n return [\\n tuple(st for st in sts) if len(sts) > 1 else sts[0]\\n for sts in sources_and_target\\n ]\",\n \"def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\\n for downstream_key in self.downstream_deps:\\n relationship = GraphRelationship(\\n start_key=self.table_key,\\n start_label=TableMetadata.TABLE_NODE_LABEL,\\n end_label=TableMetadata.TABLE_NODE_LABEL,\\n end_key=downstream_key,\\n type=TableLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\\n reverse_type=TableLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\\n attributes={}\\n )\\n yield relationship\",\n \"def _create_rel_iterator(self) -> Iterator[GraphRelationship]:\\n for downstream_key in self.downstream_deps:\\n relationship = GraphRelationship(\\n start_key=self.column_key,\\n start_label=ColumnMetadata.COLUMN_NODE_LABEL,\\n end_label=ColumnMetadata.COLUMN_NODE_LABEL,\\n end_key=downstream_key,\\n type=ColumnLineage.ORIGIN_DEPENDENCY_RELATION_TYPE,\\n reverse_type=ColumnLineage.DEPENDENCY_ORIGIN_RELATION_TYPE,\\n attributes={}\\n )\\n yield relationship\",\n \"def compare_nodes(G,all_match_pairs,match_pair,traversed,node1,node2, ports_weight):\\n logger.debug(f\\\"comparing {node1},{node2}, traversed {traversed}\\\")\\n nbrs1 = sorted(set(G.neighbors(node1)) - set(traversed))\\n #remove dummies\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=7]))\\n nbrs2 = sorted(set(G.neighbors(node2)) - set(traversed))\\n #remove dummies\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=7]))\\n logger.debug(f\\\"node1:{node1},property: {G.nodes[node1]},neigbors1: {nbrs1}\\\")\\n logger.debug(f\\\"node2:{node2},property: {G.nodes[node2]},neigbors2: {nbrs2}\\\")\\n if not nbrs1 or not nbrs2:\\n if compare_two_nodes(G, node1, node2, ports_weight):\\n match_pair[node1] = node2\\n logger.debug(f\\\"no new neihbours, returning recursion {match_pair}\\\")\\n return\\n elif len(nbrs1)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node1} {nbrs1}\\\")\\n traversed.append(node1)\\n return\\n elif len(nbrs2)> 10:\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n traversed.append(node2)\\n logger.debug(f\\\"skipping high fanout nets due to large computation, {node2} {nbrs2}\\\")\\n return\\n\\n if node1 == node2:\\n if node1 in match_pair.keys() or node1 in match_pair.values():\\n logger.debug(\\\"avoid existing pair wise symmetry\\\")\\n return\\n logger.debug(f\\\"single node {node1}, nbrs {nbrs1}, nbr_weight {[G.get_edge_data(node1,nbr) for nbr in nbrs1]}\\\")\\n SD_nbrs= [nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]\\n ## TBD: filter based on primitive constraints\\n ## Right now will try to figure out S/D paths\\n if len(SD_nbrs) ==0:\\n logger.debug(f\\\"No SD paths found to traverse\\\")\\n match_pair[node1]=node1\\n elif len(SD_nbrs) ==1:\\n logger.debug(f\\\"traversing single S/D path {SD_nbrs}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n compare_nodes(G,all_match_pairs,match_pair,traversed,SD_nbrs[0],SD_nbrs[0],ports_weight)\\n else:\\n logger.debug(f\\\" multiple nodes diverging {SD_nbrs}\\\")\\n logger.debug(f\\\"nbr weights: {SD_nbrs} {[G.get_edge_data(node1, nbr)['weight'] for nbr in SD_nbrs ]}\\\")\\n match_pair[node1]=node1\\n traversed.append(node1)\\n new_sp=sorted(set(SD_nbrs)-set(traversed))\\n all_match_pairs_local={}\\n for nbr1,nbr2 in combinations(new_sp, 2):\\n logger.debug(f\\\"recursive pair call from single branch {nbr1} {nbr2}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n if new_pair:\\n #new_pair[nbr1]=nbr2\\n all_match_pairs_local[nbr1+'_'+nbr2] = new_pair\\n all_match_pairs_local={k: v for k, v in all_match_pairs_local.items() if len(v)>0}\\n if len(all_match_pairs_local)==1:\\n match_pair.update( all_match_pairs_local[list(all_match_pairs_local.keys())[0]])\\n logger.debug(f\\\"found inline pair: {pprint.pformat(match_pair, indent=4)}\\\")\\n else:\\n for nbr1 in new_sp:\\n if (nbr1+'_'+nbr1 not in all_match_pairs.keys()):\\n logger.debug(f\\\"recursive single branch call from single branch {nbr1} {nbr1}\\\")\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr1,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr1] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif nbrs1 == nbrs2:\\n logger.debug(f\\\"traversing converging branch\\\")\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n nbrs1=sorted(set(nbrs1)-set([node1,node2]))\\n logger.debug(f\\\"all non traversed neighbours: {nbrs1}\\\")\\n if len(nbrs1)==1:\\n nbr1=nbr2=nbrs1[0]\\n logger.debug(f\\\"keeping single converged branch inline {nbr1} {nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n else:\\n for nbr1,nbr2 in combinations_with_replacement(nbrs1,2):\\n logger.debug(f\\\"recursive call from converged branch {nbr1} {nbr2}\\\")\\n if nbr1+'_'+nbr2 not in all_match_pairs.keys():\\n new_pair={}\\n compare_nodes(G,all_match_pairs,new_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n #filtering multiple axis of symmetries with same block, ideally they should be handled by array generation\\n if new_pair:\\n all_match_pairs[nbr1+'_'+nbr2] = new_pair\\n logger.debug(f\\\"updating match pairs: {pprint.pformat(all_match_pairs, indent=4)}\\\")\\n\\n\\n elif compare_two_nodes(G,node1,node2,ports_weight):\\n nbrs1 = sorted(set([nbr for nbr in nbrs1 if G.get_edge_data(node1, nbr)['weight'] !=2]))\\n nbrs2 = sorted(set([nbr for nbr in nbrs2 if G.get_edge_data(node2, nbr)['weight'] !=2]))\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n logger.debug(f\\\"Traversing parallel branches from {node1},{node2} {nbrs1}, {nbrs2}\\\")\\n nbrs1_wt = [G.get_edge_data(node1, nbr)['weight'] for nbr in nbrs1]\\n nbrs2_wt = [G.get_edge_data(node2, nbr)['weight'] for nbr in nbrs2]\\n unique_match=find_unique_matching_branches(G,nbrs1,nbrs2,ports_weight)\\n if len(nbrs1)==0 or len(nbrs2)==0:\\n logger.debug(f\\\"no new SD neihbours, returning recursion {match_pair}\\\")\\n elif len(nbrs1) ==1 and len(nbrs2)==1:\\n logger.debug(f\\\"traversing binary branch\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed,nbrs1.pop(),nbrs2.pop(),ports_weight)\\n elif unique_match:\\n logger.debug(f'traversing unique matches {unique_match}')\\n match_pair[node1]=node2\\n traversed+=[node1,node2]\\n for nbr1,nbr2 in unique_match.items():\\n logger.debug(f\\\"recursive call from binary {node1}:{node2} to {nbr1}:{nbr2}\\\")\\n compare_nodes(G,all_match_pairs,match_pair,traversed.copy(),nbr1,nbr2,ports_weight)\\n elif len(nbrs1_wt)>len(set(nbrs1_wt))>1 and len(nbrs2_wt)>len(set(nbrs2_wt))>1:\\n logger.debug(f\\\"setting new start points {node1} {node2}\\\")\\n match_pair[node1]=node2\\n if \\\"start_point\\\" in match_pair.keys():\\n match_pair[\\\"start_point\\\"]+=[node1,node2]\\n else:\\n match_pair[\\\"start_point\\\"]=[node1,node2]\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end all traversal from binary branch {node1} {node2}\\\")\\n\\n else:\\n match_pair = {}\\n logger.debug(f\\\"end of recursion branch, matches {match_pair}\\\")\",\n \"def multi_edge():\\n from networkx.readwrite import json_graph\\n import networkx as nx\\n import autonetkit\\n # returns a house graph\\n data = {'directed': False,\\n 'graph': [],\\n 'links': [{'_ports': {'r4': 2, 'r5': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 1},\\n {'_ports': {'r2': 3, 'r4': 1},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r2': 4, 'r4': 3},\\n 'raw_interfaces': {},\\n 'source': 0,\\n 'target': 3},\\n {'_ports': {'r3': 3, 'r5': 2},\\n 'raw_interfaces': {},\\n 'source': 1,\\n 'target': 4},\\n {'_ports': {'r1': 1, 'r2': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 3, 'r2': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 3},\\n {'_ports': {'r1': 2, 'r3': 1},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 4, 'r3': 4},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r1': 5, 'r3': 5},\\n 'raw_interfaces': {},\\n 'source': 2,\\n 'target': 4},\\n {'_ports': {'r2': 2, 'r3': 2},\\n 'raw_interfaces': {},\\n 'source': 3,\\n 'target': 4}],\\n 'multigraph': True,\\n 'nodes': [{'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r4 to r5', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r4 to r2', 'id': 'eth2'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r4',\\n 'label': 'r4',\\n 'x': 675,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r5 to r4', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r5 to r3', 'id': 'eth1'}},\\n 'asn': 2,\\n 'device_type': 'router',\\n 'id': 'r5',\\n 'label': 'r5',\\n 'x': 675,\\n 'y': 500},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r1 to r2', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r1 to r3', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r1',\\n 'label': 'r1',\\n 'x': 350,\\n 'y': 400},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r2 to r3', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r2 to r4', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r2 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r2',\\n 'label': 'r2',\\n 'x': 500,\\n 'y': 300},\\n {'_ports': {0: {'category': 'physical', 'description': None},\\n 1: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth0'},\\n 2: {'category': 'physical', 'description': 'r3 to r2', 'id': 'eth1'},\\n 3: {'category': 'physical', 'description': 'r3 to r5', 'id': 'eth2'},\\n 4: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth3'},\\n 5: {'category': 'physical', 'description': 'r3 to r1', 'id': 'eth4'}},\\n 'asn': 1,\\n 'device_type': 'router',\\n 'id': 'r3',\\n 'label': 'r3',\\n 'x': 500,\\n 'y': 500}]}\\n graph = json_graph.node_link_graph(data)\\n anm = autonetkit.anm.NetworkModel()\\n g_in = anm.add_overlay(\\\"input\\\")\\n g_in._replace_graph(nx.MultiGraph(graph))\\n # TODO: check if should build overlays here rather than clone in?\\n g_phy = anm[\\\"phy\\\"]\\n g_phy._replace_graph(graph)\\n return anm\",\n \"def possible(self):\\n return [tuple(path) for path in nx.all_shortest_paths(self._gpm.Graph, source=self.source, target=self.target)]\",\n \"def indirect(stack):\\n g = nx.Graph(stack)\\n for group in nx.connected_components(g):\\n yield from map(frozenset, combinations(group, 2))\",\n \"def test_wires_to_edges_directed(self):\\n g = nx.lollipop_graph(4, 1).to_directed()\\n r = wires_to_edges(g)\\n\\n assert r == {\\n 0: (0, 1),\\n 1: (0, 2),\\n 2: (0, 3),\\n 3: (1, 0),\\n 4: (1, 2),\\n 5: (1, 3),\\n 6: (2, 0),\\n 7: (2, 1),\\n 8: (2, 3),\\n 9: (3, 0),\\n 10: (3, 1),\\n 11: (3, 2),\\n 12: (3, 4),\\n 13: (4, 3),\\n }\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def get_links(self, node):\\n\\n # TODO: send help\\n\\n if not node.label:\\n return []\\n cls = node.__class__\\n\\n return [\\n (\\n e.__src_dst_assoc__,\\n psqlgraph.Node.get_subclass_named(e.__dst_class__).label,\\n )\\n for e in psqlgraph.Edge._get_edges_with_src(cls.__name__)\\n if hasattr(psqlgraph.Node.get_subclass_named(e.__dst_class__), \\\"project_id\\\")\\n ] + [\\n (\\n e.__dst_src_assoc__,\\n psqlgraph.Node.get_subclass_named(e.__src_class__).label,\\n )\\n for e in psqlgraph.Edge._get_edges_with_dst(cls.__name__)\\n if hasattr(psqlgraph.Node.get_subclass_named(e.__src_class__), \\\"project_id\\\")\\n ]\",\n \"def create_relationships(self, source_nodes, target_nodes):\\n source_nodes = (source_nodes,) if isinstance(source_nodes, Node) else source_nodes\\n target_nodes = (target_nodes,) if isinstance(target_nodes, Node) else target_nodes\\n for source_node in source_nodes:\\n for target_node in target_nodes:\\n self.create_relationship(source_node, target_node)\",\n \"def connect_all(graph, nodeset):\\n for element in nodeset:\\n graph.add_node(element)\\n for element1 in nodeset:\\n for element2 in nodeset:\\n if not element1 == element2:\\n graph.add_edge(element1, element2)\\n return graph\",\n \"def relations(self):\\n return set(self.triples()[\\\"relation\\\"])\",\n \"def GetInOutRelationshipsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if not edge[2] in [{}, None] ]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if not edge[2] in [{}, None]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if rel in r[2]]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if rel in r[2]]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def test_edges_to_wires_directed(self):\\n g = nx.lollipop_graph(4, 1).to_directed()\\n r = edges_to_wires(g)\\n\\n assert r == {\\n (0, 1): 0,\\n (0, 2): 1,\\n (0, 3): 2,\\n (1, 0): 3,\\n (1, 2): 4,\\n (1, 3): 5,\\n (2, 0): 6,\\n (2, 1): 7,\\n (2, 3): 8,\\n (3, 0): 9,\\n (3, 1): 10,\\n (3, 2): 11,\\n (3, 4): 12,\\n (4, 3): 13,\\n }\",\n \"def common_dependency_targets(graph1, graph2, n1, n2, node_attrib='label',\\n edge_attrib='label'):\\n n1_children = dependency_children(graph1, n1, edge_attrib=edge_attrib)\\n n2_children = dependency_children(graph2, n2, edge_attrib=edge_attrib)\\n n1_rels, n2_rels = defaultdict(list), defaultdict(list)\\n\\n for source_set, target_dict in ((n1_children, n1_rels), (n2_children, n2_rels)):\\n for rel, target in source_set:\\n target_dict[rel].append(target)\\n\\n common_rels = set(n1_rels) & set(n2_rels) # intersection\\n common_deps = set()\\n for rel in common_rels:\\n for n1_target in n1_rels[rel]:\\n n1_target_word = graph1.node[n1_target][node_attrib]\\n for n2_target in n2_rels[rel]:\\n n2_target_word = graph2.node[n2_target][node_attrib]\\n if n1_target_word == n2_target_word:\\n common_deps.add( (n1_target, n2_target) )\\n return common_deps\",\n \"def process(self, source: Generator, sink: Sink) -> None:\\n for rec in source:\\n if rec:\\n log.debug(\\\"length of rec\\\", len(rec), \\\"rec\\\", rec)\\n if len(rec) == 4: # infer an edge record\\n write_edge = True\\n if \\\"subject_category\\\" in self.edge_filters:\\n if rec[0] in self._seen_nodes:\\n write_edge = True\\n else:\\n write_edge = False\\n if \\\"object_category\\\" in self.edge_filters:\\n if rec[1] in self._seen_nodes:\\n if \\\"subject_category\\\" in self.edge_filters:\\n if write_edge:\\n write_edge = True\\n else:\\n write_edge = True\\n else:\\n write_edge = False\\n if write_edge:\\n if self.inspector:\\n self.inspector(GraphEntityType.EDGE, rec)\\n sink.write_edge(rec[-1])\\n else: # infer a node record\\n if \\\"category\\\" in self.node_filters:\\n self._seen_nodes.add(rec[0])\\n if self.inspector:\\n self.inspector(GraphEntityType.NODE, rec)\\n # last element of rec is the node properties\\n sink.write_node(rec[-1])\",\n \"def connections( self, cls = None ):\\n scene = self.scene()\\n if ( not scene ):\\n return []\\n \\n if ( not cls ):\\n cls = XNodeConnection\\n \\n output = []\\n for item in scene.items():\\n if ( not isinstance(item, cls) ):\\n continue\\n \\n if ( item.inputNode() == self or item.outputNode() == self ):\\n output.append(item)\\n \\n return output\",\n \"def edge_sig(T, source=[], target=[], type_='out'):\\n case_cnt = sum([v[0] for v in T['start'].values()])\\n S = dict()\\n for a_i in source:\\n S[a_i] = dict()\\n target_ = T if type_ != 'out' else T[a_i]\\n for a_j in target_:\\n if (a_i == a_j) | (a_j not in target): continue\\n if type_ != 'out':\\n if a_i in T[a_j]: S[a_i][a_j] = T[a_j][a_i][1] / case_cnt\\n else: S[a_i][a_j] = T[a_i][a_j][1] / case_cnt\\n return S\",\n \"def graph_generation(nodes: np.ndarray, edges: np.ndarray):\\n result_nodes = []\\n result_edges = []\\n\\n last_index = nodes[-1, 0]\\n\\n done = False\\n # print(nodes)\\n for p in range(nodes.shape[0]):\\n for q in range(nodes.shape[0]):\\n if list(nodes[p, 1:-2]) == (list(nodes[q, 1:-2])) and nodes[p, nodes.shape[1] - 2] < \\\\\\n nodes[q, nodes.shape[1] - 2]:\\n tmp_node = np.append(nodes[p, 1:], np.append(nodes[q, nodes.shape[1] - 2],\\n np.append(nodes[q, nodes.shape[1] - 1],\\n np.append(nodes[p, 0],\\n nodes[q, 0]))))\\n if not done:\\n result_nodes = [tmp_node]\\n done = True\\n else:\\n result_nodes = np.concatenate((result_nodes, [tmp_node]))\\n\\n result_nodes = result_nodes[np.argsort(\\n result_nodes[:, [e for e in range(1, result_nodes.shape[1] - 2) if e % 2 != 0]].sum(axis=1)), :]\\n\\n result_nodes = np.c_[range(last_index + 1, last_index + 1 + result_nodes.shape[0]), result_nodes]\\n # print(result_nodes)\\n\\n done = False\\n for e in range(edges.shape[0]):\\n for f in range(edges.shape[0]):\\n for p in range(result_nodes.shape[0]):\\n for q in range(result_nodes.shape[0]):\\n if (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and edges[\\n f, 0] == result_nodes[p, -1] and edges[f, 1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -2] and edges[e, 1] == result_nodes[q, -2] and\\n result_nodes[p, -1] == result_nodes[q, -1]) \\\\\\n or (edges[e, 0] == result_nodes[p, -1] and edges[e, 1] == result_nodes[q, -1] and\\n result_nodes[p, -2] == result_nodes[q, -2]):\\n if not done:\\n result_edges = [[result_nodes[p, 0], result_nodes[q, 0]]]\\n done = True\\n else:\\n result_edges = np.concatenate(\\n (result_edges, [[result_nodes[p, 0], result_nodes[q, 0]]]), axis=0)\\n # print(edges)\\n\\n # print(result_edges)\\n unique_result_edges = list(Counter(str(e) for e in result_edges).keys())\\n # print(unique_result_edges)\\n final_edges = []\\n for k in range(len(unique_result_edges)):\\n for j in range(result_edges.shape[0]):\\n if str(result_edges[j]) == unique_result_edges[k]:\\n if k == 0:\\n final_edges = result_edges[j]\\n break\\n else:\\n final_edges = np.concatenate((final_edges, result_edges[j]))\\n break\\n final_edges = np.reshape(final_edges, (int(final_edges.shape[0] / 2), 2))\\n # print(final_edges.shape[0])\\n done = False\\n edge_to_remove = []\\n for j in range(final_edges.shape[0]):\\n for k in range(j + 1, final_edges.shape[0]):\\n if final_edges[j, 1] == final_edges[k, 0]:\\n if not done:\\n edge_to_remove = [[final_edges[j, 0], final_edges[k, 1]]]\\n done = True\\n else:\\n edge_to_remove = np.concatenate((edge_to_remove, [[final_edges[j, 0], final_edges[k, 1]]]))\\n # print(edge_to_remove)\\n\\n idx_to_remove = []\\n done = False\\n for j in range(edge_to_remove.shape[0]):\\n for k in range(final_edges.shape[0]):\\n if list(edge_to_remove[j]) == list(final_edges[k]):\\n if not done:\\n idx_to_remove = k\\n done = True\\n else:\\n idx_to_remove = np.append(idx_to_remove, k)\\n final_edges = np.delete(final_edges, idx_to_remove, axis=0)\\n # print(final_edges)\\n result_nodes = np.delete(result_nodes, [-1, -2], 1)\\n # print(result_nodes)\\n return result_nodes, final_edges\",\n \"def getAllEdges(mutations):\\n\\tallEdges = []\\n\\tfor mutation in mutations: \\n\\t\\tprint mutation\\n\\t\\tfor mutation2 in mutations:\\n\\t\\t\\tif not (mutation == mutation2): # No edges connecting to themselves.\\n\\t\\t\\t\\ttmp = []\\n\\t\\t\\t\\ttmp.append(mutation)\\n\\t\\t\\t\\ttmp.append(mutation2)\\n\\t\\t\\t\\tallEdges.append(tmp)\\n\\treturn allEdges\",\n \"def relations_from(self, start_node):\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def test_sources():\\n g = Graph(from_list=[\\n (1, 3, 1),\\n (2, 4, 1),\\n (2, 5, 1),\\n (3, 5, 1),\\n (4, 6, 1),\\n (5, 6, 1),\\n ])\\n g.add_node(7)\\n s = g.sources(5)\\n e = {1, 2, 3}\\n assert s == e\\n\\n s2 = g.sources(1)\\n e2 = set()\\n assert s2 == e2, s2\\n\\n s3 = g.sources(6)\\n e3 = {1, 2, 3, 4, 5}\\n assert s3 == e3\\n\\n s4 = g.sources(7)\\n e4 = set()\\n assert s4 == e4\",\n \"def relations_to(self, end_node):\",\n \"def permuteEdgeTypes(self):\\n\\t\\tpermuted_graph = copy.copy(self)\\n\\t\\t# swap about half the edges\\n\\t\\ti = len(self.graph)/2\\n\\t\\twhile i > 0:\\n\\t\\t\\t# swap \\n\\t\\t\\tsourceA, targetA = random.choice(permuted_graph.graph.keys())\\n\\t\\t\\tiTypeA, emA = permuted_graph.graph[(sourceA, targetA)]\\n\\t\\t\\tsourceB, targetB = random.choice(permuted_graph.graph.keys())\\n\\t\\t\\tiTypeB, emB = permuted_graph.graph[(sourceB, targetB)]\\n\\t\\t\\tpermuted_graph.graph[(sourceA, targetA)] = (iTypeB, emB)\\n\\t\\t\\tpermuted_graph.graph[(sourceB, targetB)] = (iTypeA, emA)\\n\\n\\t\\t\\ti -= 1\\n\\n\\t\\t# return a new graph object\\t\\t\\n\\t\\treturn permuted_graph\",\n \"def pairs_of_vertices(self):\\n pairs_of_vertices = []\\n for vertice in self.list_of_vertices:\\n for edge in vertice.edges_list:\\n if non_oriented:\\n if (vertice, edge.linked[1]) and (edge.linked[1], vertice) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n if not non_oriented:\\n if (vertice, edge.linked[1]) not in pairs_of_vertices:\\n pairs_of_vertices.append((vertice, edge.linked[1]))\\n return pairs_of_vertices\",\n \"def get_cross_synset_pairs(src_synset: Synset, dst_synset: Synset) -> list:\\n # Remove phrasal expressions from the literals\\n src_literals = remove_phrases(src_synset.literals)\\n dst_literals = remove_phrases(dst_synset.literals)\\n\\n return unique([tuple(sorted((w1, w2), key=itemgetter(0))) for w1 in src_literals for w2 in dst_literals])\",\n \"def edge_generator(n1_nodes, n2_nodes, p_in, p_out):\\n\\n e_gen = lambda n1,n2,p: [e for e in [x for x in itertools.product(n1,n2) if x[0]!=x[1]] if random.random()<p]\\n\\n between_es = e_gen(n1_nodes, n2_nodes, p_out)\\n in_n1 = e_gen(n1_nodes, n1_nodes, p_in)\\n in_n2 = e_gen(n2_nodes, n2_nodes, p_in)\\n\\n return between_es + in_n1 + in_n2\",\n \"def get_contradictory_pairs(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_has_contradiction(graph, u, v):\\n yield u, v\",\n \"def iter_links(self):\\n for site in self.iter_sites():\\n for u in range(self.dim):\\n yield tuple(list(site) + [u])\",\n \"def _get_connection(\\n source: NodeInstance, target: Optional[NodeInstance], seen: dict\\n ) -> None:\\n if source is target:\\n return None\\n for rel in source.get_requirements(target):\\n if id(rel) not in seen:\\n seen[id(rel)] = rel\",\n \"def both(self, from_to, *edge_classes):\\n records = self.client.command('SELECT both({0}) FROM {1}'\\n .format(','.join(self.coerce_class_names(edge_classes))\\n , self.coerce_class_names(from_to)))\\n return [self.get_vertex(v) for v in records[0].oRecordData['both']] \\\\\\n if records else []\",\n \"def edges(self):\\n return [(a, b) for a in self._consequences_of\\n for b in self._consequences_of[a]]\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def serialize_nx_node_to_triples(g, key, node=None):\\n\\n node = node or g and g.node.get(key) # <curie/key> # ... precis\\n\\n yield (key, 'a', node.get('type')) # <> a <type>\\n\\n for attr,value in node.items():\\n yield (key, attr, value)\\n\\n # MultiDiGraph\\n for edge in g.edge.get(key):\\n # multivalue edges\\n # <> linkTo _:ReifiedEdge\\n\\n # = BNode(), UUID\\n # = edge_url\\n s = '#e/'.join((key,uuid,))\\n yield (s, 'a', 'edgetype')\\n yield (s, 'linksFrom', key)\\n yield (s, 'linksTo', edge)\\n\\n for attr, value in edge.items():\\n yield (s, attr, edge.get(attr))\\n # _:ReifiedEdge attr[n] value[n]\",\n \"def upstream_nodes_of_type(self, target_node_name, operation_type):\\n assert target_node_name in self.node_map\\n nodes = self.nodes_of_type(operation_type)\\n nodes = [node for node in nodes if has_path(self.G2, node, target_node_name)]\\n return set(nodes)\",\n \"def generation_next(prev_gen):\\n next_gen = []\\n\\n # Iter through list of graphs\\n for original_graph in prev_gen:\\n # Select edges to nodes which are at distance 2\\n select_edges = dist2_nodepairs(original_graph)\\n\\n # Go through the list of possible selected edges and add one\\n for test_edge in select_edges:\\n test_graph = original_graph.copy()\\n test_graph.add_edge(*test_edge)\\n if (not graph_exists(test_graph, next_gen)) \\\\\\n and check_test_graph(test_graph):\\n next_gen.append(test_graph)\\n\\n return next_gen\",\n \"def _pipe(self, nodes):\\n # Collect all vertices, handling special named parameter targets separately.\\n vertices = []\\n for item in nodes:\\n if isinstance(item, EdgeDef):\\n vertices.append(EdgeDef(self._store_node(item.node), item.param))\\n else:\\n vertices.append(EdgeDef(self._store_node(item), None))\\n\\n for i in range(1, len(vertices)):\\n source = vertices[i - 1]\\n target = vertices[i]\\n\\n self._downstream[source.node].append(target)\\n self._upstream[target.node].append(EdgeDef(source.node, target.param))\",\n \"def clean_edges(self):\\n for from_node in self.all_nodes():\\n for to_node in self.all_nodes():\\n if from_node == to_node:\\n continue\\n dup = list(filter(lambda x: x.from_node == from_node and x.to_node == to_node, self.edges))\\n if len(dup) > 1:\\n for d in dup[1:]:\\n self.edges.remove(d)\",\n \"def junctions(self):\\n for node_name in self._junctions:\\n yield node_name, self._data[node_name]\",\n \"def _get_and_create_relation_objects(self, root_node):\\n relations = []\\n\\n for relation in root_node.iterdescendants(\\\"TLINK\\\"):\\n lid = relation.get(\\\"lid\\\")\\n\\n # Get relation type as a string\\n relation_type = relation.get(\\\"relType\\\")\\n\\n # Get relation_type_id\\n relation_type_id = RelationType.get_id(relation_type)\\n\\n if not relation.get(\\\"timeID\\\") and not relation.get(\\\"relatedToTime\\\"):\\n # This is event-event\\n source_eiid = relation.get(\\\"eventInstanceID\\\")\\n target_eiid = relation.get(\\\"relatedToEventInstance\\\")\\n\\n # Find source event\\n source_obj = self.find_event_by_eiid(self.events, source_eiid)\\n # Find target event\\n target_obj = self.find_event_by_eiid(self.events, target_eiid)\\n\\n else:\\n # This must be event-timex or timex-event or timex-timex\\n target_tid = relation.get(\\\"relatedToTime\\\")\\n target_eiid = relation.get(\\\"relatedToEventInstance\\\")\\n\\n source_tid = relation.get(\\\"timeID\\\")\\n source_eiid = relation.get(\\\"eventInstanceID\\\")\\n\\n\\n if source_tid and target_eiid:\\n # timex-event\\n source_obj = self.find_timex_by_tid(source_tid)\\n target_obj = self.find_event_by_eiid(self.events, target_eiid)\\n elif source_eiid and target_tid:\\n # event-timex\\n source_obj = self.find_event_by_eiid(self.events, source_eiid)\\n target_obj = self.find_timex_by_tid(target_tid)\\n elif source_tid and target_tid:\\n # timex-timex\\n source_obj = self.find_timex_by_tid(source_tid)\\n target_obj = self.find_timex_by_tid(target_tid)\\n\\n relation_obj = Relation(lid, self.text_obj, source_obj, target_obj, relation_type_id)\\n\\n # So we don't run into problems with helper.output\\n if relation_obj.is_timex_timex(): relation_obj.predicted_class = relation_type_id\\n\\n # There are sometimes duplicates which we do not want to have\\n if relation_obj not in relations:\\n relations.append(relation_obj)\\n\\n return relations\",\n \"def _append_source_and_target(self, graph):\\n graph.add_node( \\\"source\\\" )\\n graph.add_node( \\\"target\\\" )\\n \\n for leave in (n for n,d in graph.out_degree_iter() if d==0):\\n if leave is not \\\"source\\\" and leave is not \\\"target\\\":\\n graph.add_edge( leave, \\\"target\\\" )\\n \\n for root in (n for n,d in graph.in_degree_iter() if d==0):\\n if root is not \\\"source\\\" and root is not \\\"target\\\": \\n graph.add_edge( \\\"source\\\", root )\",\n \"def node_targets(self, node):\\r\\n node = self.coalesce_node(node)\\r\\n nodes =[conn[1] for conn in self.connections if conn[0] == node]\\r\\n return nodes\",\n \"def step(nodes, outputs, edges):\\n flowed = []\\n for node_name in nodes.copy():\\n if node_name in flowed:\\n continue\\n if len(nodes[node_name]) == 2:\\n if node_name in flowed:\\n continue\\n node = [int(value) for value in nodes[node_name]]\\n low_value, high_value = min(node), max(node)\\n low_flow, high_flow = edges[node_name] \\n low_dictionary, low_node_name = low_flow\\n high_dictionary, high_node_name = high_flow\\n low_node = low_dictionary.get(low_node_name, tuple())\\n high_node = high_dictionary.get(high_node_name, tuple())\\n low_dictionary[low_node_name] = low_node + (str(low_value),)\\n high_dictionary[high_node_name] = high_node + (str(high_value),)\\n nodes[node_name] = tuple()\\n if low_dictionary is nodes:\\n flowed.append(low_node_name)\\n if high_dictionary is nodes:\\n flowed.append(high_node_name)\\n return nodes, outputs, edges\",\n \"def adjacentTo()\\r\\n\\r\\n def fitsWith(self, other):\\r\\n # TODO: Can use list comprehesion??\\r\\n for i, selfEdge in enumerate(self.getEdges()):\\r\\n for j, otherEdge in other.getEdges():\\r\\n if selfEdge.fitsWith(otherEdge):\\r\\n return i, j\\r\\n return False # made it here, so no edge fits together\\r\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def generate_networkx_graphs(raw_graphs):\\n\\n source_graphs = [source_from_raw(raw) for raw in raw_graphs]\\n target_graphs = [target_from_raw(raw) for raw in raw_graphs]\\n\\n return source_graphs, target_graphs\",\n \"def test_outgoing_edge_traversals(self):\\r\\n e1 = TestEdge.create(self.v1, self.v2, numbers=12)\\r\\n e2 = TestEdge.create(self.v1, self.v3, numbers=13)\\r\\n e3 = OtherTestEdge.create(self.v2, self.v3, numbers=14)\\r\\n\\r\\n results = self.v2.outE()\\r\\n assert len(results) == 1\\r\\n assert e3 in results\\r\\n\\r\\n results = self.v2.outE(types=[TestEdge])\\r\\n assert len(results) == 0\",\n \"def neighbours(assignment): \\n for index_1, index_2 in itertools.combinations(range(len(assignment)), 2):\\n new_assign = list(assignment)\\n new_assign[index_1], new_assign[index_2] = new_assign[index_2], new_assign[index_1]\\n yield tuple(new_assign)\",\n \"def test_relationship_edges(self):\\n path = os.path.join(get_file_dir(), 'data', 'GO_edges_relationship.json')\\n with open(path, 'rt') as json_file:\\n json_files = []\\n for data in json_file:\\n json_files.append(json.loads(data))\\n for entry in json_files:\\n if entry[\\\"id\\\"] == \\\"GO:0000332__GO:0003720__part_of\\\":\\n self.assertEqual(entry[\\\"from\\\"], \\\"GO_term/GO:0000332\\\")\\n self.assertEqual(entry[\\\"to\\\"], \\\"GO_term/GO:0003720\\\")\\n self.assertEqual(entry[\\\"relationship_type\\\"], \\\"part_of\\\")\\n if entry[\\\"from\\\"] == \\\"GO_term/GO:0000335\\\":\\n self.assertEqual(entry[\\\"id\\\"], \\\"GO:0000335__GO:0006313__negatively_regulates\\\")\\n self.assertEqual(entry[\\\"to\\\"], \\\"GO_term/GO:0006313\\\")\\n self.assertEqual(entry[\\\"relationship_type\\\"], \\\"negatively_regulates\\\")\",\n \"def match_nodes(source_node, target_node):\\n\\n node_position = cmds.xform(source_node, q=True, ws=True, t=True)\\n node_rotation = cmds.xform(source_node, q=True, ws=True, ro=True)\\n cmds.xform(target_node, ws=True, t=node_position)\\n cmds.xform(target_node, ws=True, ro=node_rotation)\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def mut_space(graph: nx.Graph) -> t.Iterator[t.Tuple[int, t.List[str]]]:\\n genes = get_attr(graph, 'gene')\\n xs = sorted(chain.from_iterable(((g.P1, g.A1), (g.P2, g.A2)) for g in genes))\\n return ((g, sorted(set(x[1] for x in gg))) for g, gg in groupby(xs, key=op.itemgetter(0)))\",\n \"def adjacent(self):\\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\\n result.remove(self)\\n return result\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def getMultipleEdgesBetweenSameNodesGraph(self):\\n return create_quadEdgeCross(self)\",\n \"def _iterate_protocol(self):\\n # we can't fuzz if we don't have at least one target and one request.\\n if not self.targets:\\n raise sex.SullyRuntimeError(\\\"No targets specified in session\\\")\\n\\n if not self.edges_from(self.root.id):\\n raise sex.SullyRuntimeError(\\\"No requests specified in session\\\")\\n\\n self._reset_fuzz_state()\\n\\n for x in self._iterate_protocol_recursive(this_node=self.root, path=[]):\\n yield x\",\n \"def test_wires_to_edges(self):\\n g = nx.lollipop_graph(4, 1)\\n r = wires_to_edges(g)\\n\\n assert r == {0: (0, 1), 1: (0, 2), 2: (0, 3), 3: (1, 2), 4: (1, 3), 5: (2, 3), 6: (3, 4)}\",\n \"def _find_paired_nodes(self, graph):\\n paired_list = []\\n for line in nx.generate_edgelist(graph):\\n if ('basepair' in line):\\n if not (int(line.split(' ')[0]) in paired_list):\\n paired_list.append(int(line.split(' ')[0]))\\n if not (int(line.split(' ')[1]) in paired_list):\\n paired_list.append(int(line.split(' ')[1]))\\n return paired_list\",\n \"def get_relationships_by_genus_type_for_peers_on_date(self, source_id, destination_id, relationship_genus_type, from_, to):\\n raise errors.Unimplemented()\",\n \"def test_multiple_edge_traversal_with_type_filtering(self):\\r\\n v = TestModel.create(count=1, text='Test1')\\r\\n\\r\\n v1 = TestModel.create()\\r\\n TestEdge.create(v, v1)\\r\\n\\r\\n v2 = TestModel.create()\\r\\n OtherTestEdge.create(v, v2)\\r\\n\\r\\n v3 = TestModel.create()\\r\\n YetAnotherTestEdge.create(v, v3)\\r\\n\\r\\n v4 = OtherTestModel.create()\\r\\n TestEdge.create(v, v4)\\r\\n\\r\\n v5 = OtherTestModel.create()\\r\\n OtherTestEdge.create(v, v5)\\r\\n\\r\\n v6 = OtherTestModel.create()\\r\\n YetAnotherTestEdge.create(v, v6)\\r\\n\\r\\n assert len(v.outV()) == 6\\r\\n\\r\\n assert len(v.outV(TestEdge, OtherTestEdge)) == 4\\r\\n assert len(v.outV(TestEdge, OtherTestEdge, types=[TestModel])) == 2\",\n \"def get_inconsistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def get_sharp_relations_for_sets(follows, set_1, set_2):\\n for item_1 in set_1:\\n for item_2 in set_2:\\n if not get_sharp_relation(follows, item_1, item_2):\\n return False\\n return True\",\n \"def dfs_labeled_edges_generator(graph, source, reverse=..., has_reverse_edge=..., has_nontree_edge=..., return_labels=...): # -> tuple[Unknown, Unknown]:\\n ...\",\n \"def edges(self, and_weights=False):\\n\\n # Keep track of yielded so as not to yield (1, 2) AND (2, 1), since\\n # they are the same edge using this graph representation\\n yielded = set()\\n \\n # Iterate over the vertices in the graph\\n for vertex, neighbors in self._edges.items():\\n for neighbor in neighbors:\\n \\n # Use a frozen set to keep track of tuples without caring\\n # about the order of the elements\\n to_yield = frozenset((vertex, neighbor))\\n \\n # Seen it before, so do not yield it again\\n if to_yield in yielded:\\n continue\\n # Never seen before, add it\\n else:\\n yielded.add(to_yield)\\n\\n # Yield edge and weights if the user requested it\\n if and_weights:\\n yield (vertex, neighbor), self._weights[to_yield]\\n else:\\n yield (vertex, neighbor)\",\n \"def get_all_relations(graph, u, v):\\n return {\\n data[RELATION]\\n for data in graph.edge[u][v].values()\\n }\",\n \"def edges(self, node):\\n nID = self.n2ID[node]\\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]\",\n \"def edge_mapping(self):\\n ...\",\n \"def GetInOutRelationsForList(self, G, node, relations=[]):\\n res = {gc.InputRelations: {}, gc.OutgoingRelations : {}}\\n if len(relations) > 0:\\n outEdges = [edge for edge in G.out_edges([node], data = True) if Strings.rel in edge[2]]\\n inEdges = [edge for edge in G.in_edges([node], data = True) if Strings.rel in edge[2]]\\n \\n for rel in relations:\\n outRelations = [r for r in outEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.OutgoingRelations][rel] = outRelations\\n inRelations = [r for r in inEdges if (Strings.rel, rel) in list(r[2].items())]\\n res[gc.InputRelations][rel] = inRelations\\n return res\",\n \"def find_relationships(self, fig1, fig2):\\r\\n \\r\\n rels = []\\r\\n \\r\\n # relationship based on # of objects\\r\\n if len(fig1) == len(fig2):\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'match'})\\r\\n else:\\r\\n rels.append({'obj': 'all', 'attr': 'count', 'type': 'mismatch'})\\r\\n \\r\\n for obj, attrs in fig1.items():\\r\\n if not obj in fig2:\\r\\n # object has been removed in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'removed'})\\r\\n continue\\r\\n \\r\\n for obj in fig2:\\r\\n if not obj in fig1:\\r\\n # object is only present in fig2\\r\\n rels.append({'obj': obj, 'attr': 'all', 'type': 'added'})\\r\\n continue\\r\\n \\r\\n for attr in fig2[obj]:\\r\\n rel = {'obj': obj, 'attr': attr}\\r\\n \\r\\n if attr in fig1[obj] and fig1[obj][attr] == fig2[obj][attr]:\\r\\n rel['type'] = 'match'\\r\\n else:\\r\\n partial_match = False\\r\\n for subvalue in fig2[obj][attr]:\\r\\n if attr in fig1[obj] and subvalue in fig1[obj][attr]:\\r\\n partial_match = True\\r\\n \\r\\n if partial_match:\\r\\n rel['type'] = 'partial'\\r\\n else:\\r\\n rel['type'] = 'mismatch'\\r\\n rel['old_values'] = ','.join(fig1[obj].get(attr, ['missing']))\\r\\n rel['new_values'] = ','.join(fig2[obj][attr])\\r\\n if rel['new_values'].isdigit() and rel['old_values'].isdigit():\\r\\n rel['diff'] = float(rel['new_values']) - float(rel['old_values'])\\r\\n del rel['old_values']\\r\\n del rel['new_values']\\r\\n \\r\\n rels.append(rel)\\r\\n \\r\\n return rels\",\n \"def find_type_tuples_relationship(self, type_tuples, baseline_dict=None, ignore_sqns=False, force_deep_scan=False, max_similarity=0.8):\\n\\n # if self.VERBOSE:\\n # print u'Find type tuples relationships: %s' % (u', '.join(map(unicode, type_tuples.keys())))\\n\\n i_count = 0\\n types_suggested_relations = defaultdict(list)\\n \\\"\\\"\\\"@type: dict of (ProductType, list[ProductType.Relation])\\\"\\\"\\\"\\n\\n type_tuples_for_deep_scan = dict(type_tuples)\\n dict_types = baseline_dict or self.get_type_tuples(meaningful_only=True)\\n if ignore_sqns:\\n # Optimize lookup data set - do not iterate for known types, just map as identical\\n for t in type_tuples:\\n if t in dict_types:\\n # Must always find identical relation\\n rel = self.compare_types(t, t)\\n types_suggested_relations[t].append(rel)\\n if force_deep_scan:\\n del type_tuples_for_deep_scan[t]\\n\\n if not force_deep_scan and types_suggested_relations:\\n # If identical types have been found deep scan is not required\\n type_tuples_for_deep_scan.clear()\\n # if self.VERBOSE: print \\\"Identical type 's been found, skip deep scan\\\"\\n\\n for t1, t2 in itertools.product(type_tuples_for_deep_scan.viewitems(), dict_types.viewitems()):\\n type_input = t1[0]\\n \\\"\\\"\\\"@type: ProductType\\\"\\\"\\\"\\n type_dict = t2[0]\\n \\\"\\\"\\\"@type: ProductType\\\"\\\"\\\"\\n\\n rel = self.compare_types(type_input, type_dict, max_similarity)\\n\\n if rel:\\n types_suggested_relations[type_input].append(rel)\\n\\n i_count += 1\\n if self.VERBOSE and i_count % 10000 == 0: print(u'.', end='')\\n if self.VERBOSE and i_count % 1000000 == 0: print(i_count)\\n if self.VERBOSE and i_count >= 10000:\\n print()\\n # print u'Suggested %d types' % len(types_suggested_relations)\\n\\n return types_suggested_relations\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def test_edges_to_wires(self):\\n g = nx.lollipop_graph(4, 1)\\n r = edges_to_wires(g)\\n\\n assert r == {(0, 1): 0, (0, 2): 1, (0, 3): 2, (1, 2): 3, (1, 3): 4, (2, 3): 5, (3, 4): 6}\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6733386","0.66894716","0.6501065","0.6438232","0.6384303","0.6357606","0.6318119","0.62464094","0.6178377","0.61569047","0.60460675","0.5998505","0.5993081","0.5944631","0.59069026","0.5852232","0.5815307","0.58126503","0.57924825","0.5792085","0.57872975","0.5755452","0.57431","0.57418144","0.5739292","0.5676967","0.5668482","0.56411105","0.56407917","0.563521","0.562076","0.56124675","0.56122077","0.55693424","0.5560091","0.55596435","0.5554318","0.5551215","0.5525946","0.5522811","0.55120337","0.5503584","0.5499551","0.5486854","0.54851025","0.5480861","0.5480579","0.5473311","0.54712975","0.5453227","0.5448918","0.54444295","0.54347754","0.54263616","0.5420258","0.54129034","0.5397348","0.5395464","0.53856426","0.53818","0.53752744","0.53734523","0.5370008","0.5366219","0.53661126","0.5363253","0.535707","0.53565186","0.53513724","0.5347893","0.53478914","0.53459793","0.53454846","0.5343922","0.53358275","0.5334081","0.5330988","0.53223157","0.5312779","0.5306844","0.5301787","0.5301762","0.5300392","0.530003","0.52930415","0.52930135","0.52923596","0.52915716","0.5285234","0.52749616","0.5273752","0.5265414","0.52648985","0.5258146","0.52539104","0.5251492","0.52502567","0.5247166","0.5240833","0.5237108"],"string":"[\n \"0.6733386\",\n \"0.66894716\",\n \"0.6501065\",\n \"0.6438232\",\n \"0.6384303\",\n \"0.6357606\",\n \"0.6318119\",\n \"0.62464094\",\n \"0.6178377\",\n \"0.61569047\",\n \"0.60460675\",\n \"0.5998505\",\n \"0.5993081\",\n \"0.5944631\",\n \"0.59069026\",\n \"0.5852232\",\n \"0.5815307\",\n \"0.58126503\",\n \"0.57924825\",\n \"0.5792085\",\n \"0.57872975\",\n \"0.5755452\",\n \"0.57431\",\n \"0.57418144\",\n \"0.5739292\",\n \"0.5676967\",\n \"0.5668482\",\n \"0.56411105\",\n \"0.56407917\",\n \"0.563521\",\n \"0.562076\",\n \"0.56124675\",\n \"0.56122077\",\n \"0.55693424\",\n \"0.5560091\",\n \"0.55596435\",\n \"0.5554318\",\n \"0.5551215\",\n \"0.5525946\",\n \"0.5522811\",\n \"0.55120337\",\n \"0.5503584\",\n \"0.5499551\",\n \"0.5486854\",\n \"0.54851025\",\n \"0.5480861\",\n \"0.5480579\",\n \"0.5473311\",\n \"0.54712975\",\n \"0.5453227\",\n \"0.5448918\",\n \"0.54444295\",\n \"0.54347754\",\n \"0.54263616\",\n \"0.5420258\",\n \"0.54129034\",\n \"0.5397348\",\n \"0.5395464\",\n \"0.53856426\",\n \"0.53818\",\n \"0.53752744\",\n \"0.53734523\",\n \"0.5370008\",\n \"0.5366219\",\n \"0.53661126\",\n \"0.5363253\",\n \"0.535707\",\n \"0.53565186\",\n \"0.53513724\",\n \"0.5347893\",\n \"0.53478914\",\n \"0.53459793\",\n \"0.53454846\",\n \"0.5343922\",\n \"0.53358275\",\n \"0.5334081\",\n \"0.5330988\",\n \"0.53223157\",\n \"0.5312779\",\n \"0.5306844\",\n \"0.5301787\",\n \"0.5301762\",\n \"0.5300392\",\n \"0.530003\",\n \"0.52930415\",\n \"0.52930135\",\n \"0.52923596\",\n \"0.52915716\",\n \"0.5285234\",\n \"0.52749616\",\n \"0.5273752\",\n \"0.5265414\",\n \"0.52648985\",\n \"0.5258146\",\n \"0.52539104\",\n \"0.5251492\",\n \"0.52502567\",\n \"0.5247166\",\n \"0.5240833\",\n \"0.5237108\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56193626"},"document_rank":{"kind":"string","value":"31"}}},{"rowIdx":20174,"cells":{"query":{"kind":"string","value":"Returns an iterator over inconsistent edges"},"document":{"kind":"string","value":"def get_inconsistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if not pair_is_consistent(graph, u, v):\n yield u, v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v","def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for neighbour in self.__graph_dict[node]:\n # Since all edges go both ways, we need only return one of them.\n if {neighbour, node} not in edges:\n edges.append({node, neighbour})\n yield (node, neighbour)","def edges(self):\n for e in self._edges:\n yield e","def edges(self):\n vertices = self.vertices(closed=True)\n\n for i in range(len(self)):\n yield(vertices[:, i], vertices[:, i+1])","def edges_iter(self) -> Generator:\n for u, v, k, data in self.graph.edges(keys=True, data=True):\n yield u, v, k, data","def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target","def edges(self):\n\t\tleftback = self.center + self.left*self.wr - self.forward*self.hr\n\t\tleftfront = self.center + self.left*self.wr + self.forward*self.hr\n\t\trightfront = self.center - self.left*self.wr + self.forward*self.hr\n\t\trightback = self.center - self.left*self.wr - self.forward*self.hr\n\t\tyield (leftback, leftfront)\n\t\tyield (leftfront, rightfront)\n\t\tyield (rightfront, rightback)\n\t\tyield (rightback, leftback)","def iter_edges(self):\n yield self.upperleft, self.upperright\n yield self.upperright, self.bottomright\n yield self.bottomright, self.bottomleft\n yield self.bottomleft, self.upperleft","def iter_edges(self):\n yield self.upperleft, self.upperright\n yield self.upperright, self.bottomright\n yield self.bottomright, self.bottomleft\n yield self.bottomleft, self.upperleft","def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v","def get_consistent_edges(graph):\n for u, v in _iter_pairs(graph):\n if pair_is_consistent(graph, u, v):\n yield u, v","def edges(self):\n return self.dovetails + self.containments + self.internals","def edges(self):\n edges = []\n for key in self._g:\n if self._g[key]:\n for value in self._g[key]:\n edges.append((key, value))\n return edges","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def inequality_generator(self):\n for H in self.Hrepresentation():\n if H.is_inequality():\n yield H","def get_exiting_edges(self,node):\n exit_edge_pattern=re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_edges=[]\n for index,edge in enumerate(self.edges):\n if re.match(exit_edge_pattern,edge):\n exit_edges.append(edge)\n return exit_edges","def getEdges(self):\n\n return [(cell, vertice) for cell in self.adjacent.keys() for vertice in self.adjacent[cell]]","def edges(self):\n return [(a, b) for a in self._consequences_of\n for b in self._consequences_of[a]]","def __iter__(self):\n return iter(self.adjacent)","def iter_edges(self) -> Iterable[EdgeTuple]:\n # FIXME: handle case where initializing with ddict data from query.\n # If implemented here (adding **d to the edge factory arguments), it\n # will always attempt to update the database on a per-read basis!\n return (\n (u, v, dict(self.edge_attr_dict_factory(self.network, u, v)))\n for u, v, d in self.network.edges.iter_edges()\n )","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({neighbour, vertex})\n return edges","def __filterEdges(self):","def edges(self):\r\n return self.__generate_edges()","def real_out_edges_iter (self, node):\n return (data for data in self.network.out_edges_iter(node, data=True)\n if data[2].type in (self.TYPE_LINK_STATIC, self.TYPE_LINK_DYNAMIC))","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def test_edges(self):\n\n edge_list = self.g.edges()\n self.assertEqual(42, len(edge_list))\n\n # p1 p3 and p3 p1 are valid edges\n t1 = ('p1', 'p3')\n self.assertTrue(t1 in edge_list)\n\n t2 = ('p3', 'p1')\n self.assertTrue(t2 in edge_list)\n\n made_up = ('z1', 'q123')\n self.assertFalse(made_up in edge_list)\n\n return None","def iterate_edges(\n self, verbs=None, directions=None, nodes=None\n ) -> Iterable[Edge]:","def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\n if include_metadata:\n return iter(\n [\n (e[\"source\"], e[\"target\"], _node_to_metadata(e[\"properties\"]))\n for e in (\n self._g.V()\n .outE()\n .project(\"target\", \"source\", \"properties\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .by(__.valueMap(True))\n .toList()\n )\n ]\n )\n return iter(\n [\n (e[\"source\"], e[\"target\"])\n for e in self._g.V()\n .outE()\n .project(\"target\", \"source\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .toList()\n ]\n )","def edges(self):\n es = []\n for vertex1 in self.vertices():\n for vertex2 in self.out_vertices(vertex1):\n es.append(self[vertex1][vertex2])\n return es","def edges(self, and_weights=False):\n\n # Keep track of yielded so as not to yield (1, 2) AND (2, 1), since\n # they are the same edge using this graph representation\n yielded = set()\n \n # Iterate over the vertices in the graph\n for vertex, neighbors in self._edges.items():\n for neighbor in neighbors:\n \n # Use a frozen set to keep track of tuples without caring\n # about the order of the elements\n to_yield = frozenset((vertex, neighbor))\n \n # Seen it before, so do not yield it again\n if to_yield in yielded:\n continue\n # Never seen before, add it\n else:\n yielded.add(to_yield)\n\n # Yield edge and weights if the user requested it\n if and_weights:\n yield (vertex, neighbor), self._weights[to_yield]\n else:\n yield (vertex, neighbor)","def get_entering_edges(self,node):\n enter_edge_pattern=re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_edges=[]\n for index,edge in enumerate(self.edges):\n if re.match(enter_edge_pattern,edge):\n enter_edges.append(edge)\n return enter_edges","def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))","def bounded_edges(self):\n obj = self.Vrepresentation()\n edges = []\n for i in range(len(obj)):\n if not obj[i].is_vertex(): continue\n for j in range(i+1,len(obj)):\n if not obj[j].is_vertex(): continue\n if self.vertex_adjacency_matrix()[i,j] == 0: continue\n yield (obj[i], obj[j])","def edges(self):\n return self.generate_edges()","def edges(self):\n return [(k, val) for k, v in self.dict.iteritems() for val in v]","def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\n if include_metadata:\n return [\n (\n self._names.get_name(u),\n self._names.get_name(v),\n self._meta.get_edge(\n self._names.get_name(u), self._names.get_name(v)\n ),\n )\n for u, v in self._nk_graph.iterEdges()\n ]\n return [\n (self._names.get_name(u), self._names.get_name(v))\n for u, v in self._nk_graph.iterEdges()\n ]","def edges(self):\n result = set() # avoid double-reporting edges of undirected graph\n for secondary_map in self._outgoing.values():\n result.update(secondary_map.values()) # add edges to resulting set\n return result","def edges(self):\n return self.__generate_edges()","def edges(self):\n return self.__generate_edges()","def edges(self):\n return self.__generate_edges()","def edges(self):\n return [edge(self.vertices[i - 1], self.vertices[(i)]) for i in range(-1, len(self.vertices))]","def __iter__(self):\n it = self.ctx.Iterator5(\n self.addr,\n ScType.EdgeDCommonConst,\n ScType.Unknown,\n ScType.EdgeAccessConstPosPerm,\n self.relAddr)\n\n return Iterator(it)","def get_next_edge(node: str) -> Iterator[Edge]:\n if node not in node_to_edges:\n return\n yield\n\n for edge in node_to_edges[node]:\n yield edge","def incident_edges(self,v,outgoing=True):\n adj = self._outgoing if outgoing else self._incoming\n for edge in adj[v].values():\n yield edge","def get_edges(self):\n return_set = set()\n for outer_index, outer_list in enumerate(self._adjmatrix):\n for inner_index, inner_item in enumerate(outer_list):\n if(inner_item):\n return_set.add(\n (self._name[outer_index],\n self._name[inner_index]))\n return return_set","def getOutEdges(self):\n edges = []\n for edict in mm.G[self].values():\n for k in edict.keys():\n edges.append(edict.get(k).get(\"edge\"))\n \n return edges","def add_all_edges(self):\n for n1 in self.vertices():\n for n2 in self.vertices():\n if n1 != n2:\n self.add_edge((n1, n2))","def iter_edges(self):\n counter = 0\n\n def iterate(node, depth):\n\n nonlocal counter\n no = counter\n\n if isinstance(node, Branch):\n for child in (node.left, node.right):\n counter += 1\n yield no, counter, node, child, depth + 1\n if isinstance(child, Branch):\n yield from iterate(child, depth=depth + 1)\n\n yield None, 0, None, self, 0\n yield from iterate(self, depth=0)","def edges(self):\n edge_list = []\n for node1 in self.node_dict:\n for node2 in self.node_dict[node1]:\n edge_list.append((node1,\n node2,\n self.node_dict[node1][node2]))\n return edge_list","def neighbor_out_iterator(self, vertex):\n return iter(set(self._backend.iterator_out_nbrs(vertex)))","def dfs_iter(self, root):\n stack = self.dep_graph.out_edges(root)\n while stack:\n edge = stack.pop()\n stack += self.dep_graph.out_edges(edge[1])\n yield edge","def generate_edges(graph):\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges","def edges(self):\n bag = set()\n for v in range(self._V):\n selfLoops = 0\n for e in self._adj[v]:\n if e.other(v) > v:\n bag.add(e)\n # only add one copy of each self loop (self loops will be consecutive)\n elif e.other(v) == v:\n if selfLoops % 2 == 0: bag.add(e)\n selfLoops += 1\n return bag","def get_edges(self):\n return \\\n set({\n edge\n for node in self.nodeset\n for edge in node.get_incident_edges()\n })","def eligible_edges(self):\n if len(self.edges) == 4:\n return [self.edges[0], self.edges[2]]\n return []","def test_incoming_edge_traversals(self):\r\n e1 = TestEdge.create(self.v1, self.v2, numbers=12)\r\n e2 = TestEdge.create(self.v1, self.v3, numbers=13)\r\n e3 = OtherTestEdge.create(self.v2, self.v3, numbers=14)\r\n\r\n results = self.v2.inE()\r\n assert len(results) == 1\r\n assert e1 in results\r\n\r\n results = self.v2.inE(types=[OtherTestEdge])\r\n assert len(results) == 0","def iter_edges(self, edge_uuids=None):\n\n if edge_uuids is None:\n for edge in self._edges.values():\n yield Edge.from_edge(edge)\n else:\n for edge_uuid in edge_uuids:\n yield Edge.from_edge(self._edges[edge_uuid])","def get_eulerian_graph_edges(bbox, source):\n osm_graph = OSMGraph(bbox, source)\n # input all nodes and get odd nodes, update node attributes\n odd_nodes = get_odd_nodes(osm_graph.nodes_dict)\n\n # initialize all_pairs_list\n all_pairs_list = []\n\n # if there are 6 or fewer odd nodes look for all possible options,\n # otherwise look for just three basic pairing options\n\n if len(odd_nodes) <= 10:\n print(\"ROBUST PAIRING FUNCTION\")\n all_pairs_list = get_list_of_all_pairs_lists(odd_nodes)\n\n else:\n print(\"CHEAP PAIRING FUNCTION\")\n all_pairs_list = get_list_of_all_pairs_lists_short(odd_nodes)\n\n for item in all_pairs_list:\n print(\"\\n\\nPair option:\", item)\n print(\"Pair option len:\", len(item))\n\n dict_pairings_lists_lengths = get_dict_pairings_lists_lengths(\n all_pairs_list, osm_graph\n )\n twice_traversals_edges = get_twice_traversals_edges(dict_pairings_lists_lengths)\n updated_graph_instance = update_twice_traversal_edges(\n twice_traversals_edges, osm_graph\n )\n return updated_graph_instance","def edges( self ):\n raise NotImplementedError(\"edges\");","def test_get_edges_2(self):\n G = [[0, [0, 1, 2, 3]], [1, [0, 2]], [2, [0, 1, 3]], [3, [0, 2, 3]]]\n edges = kargermincut.get_edges(G)\n edges = kargermincut.remove_self_loops(edges)\n self.assertEqual(edges, [[0, 1], [0, 2], [0, 3], [1, 2], [2, 3]])","def incoming_edge_iterator(self, vertices, labels=True):\n if vertices is None:\n vertices = self\n elif vertices in self:\n vertices = [vertices]\n else:\n vertices = [v for v in vertices if v in self]\n return self._backend.iterator_in_edges(vertices, labels)","def adjacent(self):\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\n result.remove(self)\n return result","def test_adjacent_unpresent(graph_with_edges):\n with pytest.raises(ValueError):\n graph_with_edges.adjacent('Captain Picard', 'Star Wars')","def path2edge(iterable,graph):\r\n return (graph.es[graph.get_eid(pair[0],pair[1])] for pair in pairwise(iterable))","def _get_non_matched_edges(self):\n return list(itertools.product(self.coords.values(), self.DIRECTIONS))","def _all_edges(node: FMVGraphNode) -> Set[FMVGraphEdge]:\n rval = set([e for e in node.edges\n if e.predicate not in skip_fhir_predicates and e.type_node.node not in skip_fhir_types])\n for p in node.parents:\n if p.node not in skip_fhir_types:\n rval.update(FHIROntologyTable._all_edges(p))\n return rval","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n edges.append({vertex, neighbour})\n return edges","def neighbors_iter(node, topology):\n return topology[node]","def edges(self, node):\n nID = self.n2ID[node]\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]","def outgoing_edge_iterator(self, vertices, labels=True):\n if vertices is None:\n vertices = self\n elif vertices in self:\n vertices = [vertices]\n else:\n vertices = [v for v in vertices if v in self]\n return self._backend.iterator_out_edges(vertices, labels)","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def iterate_adjacent(position):\n return iter(_board_graph[position])","def adjacentTo()\r\n\r\n def fitsWith(self, other):\r\n # TODO: Can use list comprehesion??\r\n for i, selfEdge in enumerate(self.getEdges()):\r\n for j, otherEdge in other.getEdges():\r\n if selfEdge.fitsWith(otherEdge):\r\n return i, j\r\n return False # made it here, so no edge fits together\r","def edges(self):\n edges = []\n for key in self:\n if key:\n for edge in self[key]:\n edges.append((key, edge))\n return edges","def edges(adj_mat, vertices):\n return [(i,j) for i,j in\n vertices if (i < j and adj_mat[i][j] == 1)]","def edgesWithVertices(self):\n\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}","def GetInteriorEdgesTri(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesTri()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesTri()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def test_adjacent_none(graph_with_edges):\n assert graph_with_edges.adjacent('B', 'A') is False","def get_edges(self) -> []:\n graph_edges = []\n\n for vertex in self.adj_list:\n for connection in self.adj_list[vertex]:\n if (vertex, connection) not in graph_edges and (connection, vertex) not in graph_edges:\n graph_edges.append((vertex, connection))\n\n return graph_edges","def get_internal_edges(self):\n raise NotImplementedError()","def edges(self):\r\n return [\r\n (parent, child)\r\n for parent in self._children_of\r\n for child in self._children_of[parent]\r\n ]","def neighbor_in_iterator(self, vertex):\n return iter(set(self._backend.iterator_in_nbrs(vertex)))","def eligible_edges(self):\n return self.edges","def edges(self):\n edges = []\n for key in self:\n if key:\n for edge in self[key]:\n edges.append((key, edge, self[key][edge]))\n return edges","def get_right_edges(G,G2):\n\tsame_edges,different_edges=set(),set()\n\tfor e in G.edges():\n\t\tn1,n2=e\n\t\tif G2.has_edge(n1,n2): same_edges.add(e)\n\t\telse: different_edges.add(e)\n\treturn same_edges,different_edges","def get_unvisited_neighbours(self, grid):\n\t\tfor neighbour in self.get_neighbours(grid):\n\t\t\tif not neighbour.visited:\n\t\t\t\tyield neighbour","def find_boundary(edges):\n\n inputs = set([x[0] for x in edges])\n outputs = set([x[1] for x in edges])\n for e in edges:\n inputs.discard(e[1])\n outputs.discard(e[0])\n return inputs, outputs","def extract_edges(graph):\n return graph.get_edges()","def cw_face_edges(self,face):\n\n l0 = self.region_link[face]\n if face == self.left_region[l0]:\n l0 = (l0[1], l0[0])\n l = l0\n\n traversing = True\n edges = []\n while traversing:\n edges.append(l)\n r = self.right_region[l]\n if r == face:\n l = self.succ_right[l]\n else:\n l = self.succ_left[l]\n if l == l0:\n traversing = False\n return edges","def vertices(self):\n \n yielded = set()\n \n # Iterate over every tuple of edges, e.g. ..., (1, 2), (4, 3), ...\n for vertices in self.edges():\n # Iterate over every vertex in the tuple, e.g. ..., 1, 2, 4, 3, ...\n for vertex in vertices:\n # Yield if it has not been yielded already\n if vertex not in yielded:\n yield vertex","def GetInteriorEdgesPent(self):\n\n if not isinstance(self.all_edges,np.ndarray):\n self.GetEdgesPent()\n if not isinstance(self.edges,np.ndarray):\n self.GetBoundaryEdgesPent()\n\n sorted_all_edges = np.sort(self.all_edges,axis=1)\n sorted_boundary_edges = np.sort(self.edges,axis=1)\n\n x = []\n for i in range(self.edges.shape[0]):\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\n pos_interior_edges = np.where(interior_edges==0)[0]\n if pos_interior_edges.shape[0] != 0:\n x.append(pos_interior_edges)\n\n edge_aranger = np.arange(self.all_edges.shape[0])\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\n interior_edges = self.all_edges[edge_aranger,:]\n\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\n edge_flags[edge_aranger] = 0\n\n self.interior_edges = interior_edges\n return interior_edges, edge_flags","def iterate_exchanges(self) -> Iterator[ExchangeInterface]:\n with self.database.conn.read_ctx() as cursor:\n excluded = self.database.get_settings(cursor).non_syncing_exchanges\n for exchanges in self.connected_exchanges.values():\n for exchange in exchanges:\n # We are not yielding excluded exchanges\n if exchange.location_id() not in excluded:\n yield exchange","def remove_inconsistent_edges(graph: BELGraph) -> None:\n for u, v in get_inconsistent_edges(graph):\n edges = [(u, v, k) for k in graph[u][v]]\n graph.remove_edges_from(edges)","def edges_is_closed_curve(edges):\n e_prev = first = edges[0]\n for e in edges[1:]:\n if e_prev[1] != e[0]:\n if e_prev[1] == first[0]:\n # new loop\n first = e\n else:\n return False\n e_prev = e\n if e_prev[1] != first[0]:\n return False\n return True","def __iter__(self) -> Iterable[\"AbstractLane\"]:\n for origin in self.graph:\n for destination in self.graph[origin]:\n for index, lane in self.graph[origin][destination].items():\n yield lane","def adjacent(self):\r\n d = 0\r\n while d < 4:\r\n a = self.getAdjacent(d)\r\n if a is not None:\r\n yield a\r\n d += 1","def edges(self):\n return self.graph.edges"],"string":"[\n \"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\\n for u, v in graph.edges():\\n if not pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def edges(self) -> Iterable[Tuple[Node]]:\\n edges = []\\n for node in self.__graph_dict.keys():\\n for neighbour in self.__graph_dict[node]:\\n # Since all edges go both ways, we need only return one of them.\\n if {neighbour, node} not in edges:\\n edges.append({node, neighbour})\\n yield (node, neighbour)\",\n \"def edges(self):\\n for e in self._edges:\\n yield e\",\n \"def edges(self):\\n vertices = self.vertices(closed=True)\\n\\n for i in range(len(self)):\\n yield(vertices[:, i], vertices[:, i+1])\",\n \"def edges_iter(self) -> Generator:\\n for u, v, k, data in self.graph.edges(keys=True, data=True):\\n yield u, v, k, data\",\n \"def iteredges(self):\\n for source, targets in self.successors.items():\\n for target in targets:\\n yield source, target\",\n \"def edges(self):\\n\\t\\tleftback = self.center + self.left*self.wr - self.forward*self.hr\\n\\t\\tleftfront = self.center + self.left*self.wr + self.forward*self.hr\\n\\t\\trightfront = self.center - self.left*self.wr + self.forward*self.hr\\n\\t\\trightback = self.center - self.left*self.wr - self.forward*self.hr\\n\\t\\tyield (leftback, leftfront)\\n\\t\\tyield (leftfront, rightfront)\\n\\t\\tyield (rightfront, rightback)\\n\\t\\tyield (rightback, leftback)\",\n \"def iter_edges(self):\\n yield self.upperleft, self.upperright\\n yield self.upperright, self.bottomright\\n yield self.bottomright, self.bottomleft\\n yield self.bottomleft, self.upperleft\",\n \"def iter_edges(self):\\n yield self.upperleft, self.upperright\\n yield self.upperright, self.bottomright\\n yield self.bottomright, self.bottomleft\\n yield self.bottomleft, self.upperleft\",\n \"def _iter_pairs(graph):\\n for u, v in set(graph.edges_iter()):\\n yield u, v\",\n \"def get_consistent_edges(graph):\\n for u, v in _iter_pairs(graph):\\n if pair_is_consistent(graph, u, v):\\n yield u, v\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def edges(self):\\n edges = []\\n for key in self._g:\\n if self._g[key]:\\n for value in self._g[key]:\\n edges.append((key, value))\\n return edges\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def inequality_generator(self):\\n for H in self.Hrepresentation():\\n if H.is_inequality():\\n yield H\",\n \"def get_exiting_edges(self,node):\\n exit_edge_pattern=re.compile('edge_{0}_(?P<end_node>\\\\w+)_(?P<iterator>\\\\w+)'.format(node))\\n exit_edges=[]\\n for index,edge in enumerate(self.edges):\\n if re.match(exit_edge_pattern,edge):\\n exit_edges.append(edge)\\n return exit_edges\",\n \"def getEdges(self):\\n\\n return [(cell, vertice) for cell in self.adjacent.keys() for vertice in self.adjacent[cell]]\",\n \"def edges(self):\\n return [(a, b) for a in self._consequences_of\\n for b in self._consequences_of[a]]\",\n \"def __iter__(self):\\n return iter(self.adjacent)\",\n \"def iter_edges(self) -> Iterable[EdgeTuple]:\\n # FIXME: handle case where initializing with ddict data from query.\\n # If implemented here (adding **d to the edge factory arguments), it\\n # will always attempt to update the database on a per-read basis!\\n return (\\n (u, v, dict(self.edge_attr_dict_factory(self.network, u, v)))\\n for u, v, d in self.network.edges.iter_edges()\\n )\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({neighbour, vertex})\\n return edges\",\n \"def __filterEdges(self):\",\n \"def edges(self):\\r\\n return self.__generate_edges()\",\n \"def real_out_edges_iter (self, node):\\n return (data for data in self.network.out_edges_iter(node, data=True)\\n if data[2].type in (self.TYPE_LINK_STATIC, self.TYPE_LINK_DYNAMIC))\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def test_edges(self):\\n\\n edge_list = self.g.edges()\\n self.assertEqual(42, len(edge_list))\\n\\n # p1 p3 and p3 p1 are valid edges\\n t1 = ('p1', 'p3')\\n self.assertTrue(t1 in edge_list)\\n\\n t2 = ('p3', 'p1')\\n self.assertTrue(t2 in edge_list)\\n\\n made_up = ('z1', 'q123')\\n self.assertFalse(made_up in edge_list)\\n\\n return None\",\n \"def iterate_edges(\\n self, verbs=None, directions=None, nodes=None\\n ) -> Iterable[Edge]:\",\n \"def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\\n if include_metadata:\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"], _node_to_metadata(e[\\\"properties\\\"]))\\n for e in (\\n self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\", \\\"properties\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .by(__.valueMap(True))\\n .toList()\\n )\\n ]\\n )\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"])\\n for e in self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .toList()\\n ]\\n )\",\n \"def edges(self):\\n es = []\\n for vertex1 in self.vertices():\\n for vertex2 in self.out_vertices(vertex1):\\n es.append(self[vertex1][vertex2])\\n return es\",\n \"def edges(self, and_weights=False):\\n\\n # Keep track of yielded so as not to yield (1, 2) AND (2, 1), since\\n # they are the same edge using this graph representation\\n yielded = set()\\n \\n # Iterate over the vertices in the graph\\n for vertex, neighbors in self._edges.items():\\n for neighbor in neighbors:\\n \\n # Use a frozen set to keep track of tuples without caring\\n # about the order of the elements\\n to_yield = frozenset((vertex, neighbor))\\n \\n # Seen it before, so do not yield it again\\n if to_yield in yielded:\\n continue\\n # Never seen before, add it\\n else:\\n yielded.add(to_yield)\\n\\n # Yield edge and weights if the user requested it\\n if and_weights:\\n yield (vertex, neighbor), self._weights[to_yield]\\n else:\\n yield (vertex, neighbor)\",\n \"def get_entering_edges(self,node):\\n enter_edge_pattern=re.compile('edge_(?P<begin_node>\\\\w+)_{0}_(?P<iterator>\\\\w+)'.format(node))\\n enter_edges=[]\\n for index,edge in enumerate(self.edges):\\n if re.match(enter_edge_pattern,edge):\\n enter_edges.append(edge)\\n return enter_edges\",\n \"def all_pairs(self):\\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))\",\n \"def bounded_edges(self):\\n obj = self.Vrepresentation()\\n edges = []\\n for i in range(len(obj)):\\n if not obj[i].is_vertex(): continue\\n for j in range(i+1,len(obj)):\\n if not obj[j].is_vertex(): continue\\n if self.vertex_adjacency_matrix()[i,j] == 0: continue\\n yield (obj[i], obj[j])\",\n \"def edges(self):\\n return self.generate_edges()\",\n \"def edges(self):\\n return [(k, val) for k, v in self.dict.iteritems() for val in v]\",\n \"def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\\n if include_metadata:\\n return [\\n (\\n self._names.get_name(u),\\n self._names.get_name(v),\\n self._meta.get_edge(\\n self._names.get_name(u), self._names.get_name(v)\\n ),\\n )\\n for u, v in self._nk_graph.iterEdges()\\n ]\\n return [\\n (self._names.get_name(u), self._names.get_name(v))\\n for u, v in self._nk_graph.iterEdges()\\n ]\",\n \"def edges(self):\\n result = set() # avoid double-reporting edges of undirected graph\\n for secondary_map in self._outgoing.values():\\n result.update(secondary_map.values()) # add edges to resulting set\\n return result\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def edges(self):\\n return [edge(self.vertices[i - 1], self.vertices[(i)]) for i in range(-1, len(self.vertices))]\",\n \"def __iter__(self):\\n it = self.ctx.Iterator5(\\n self.addr,\\n ScType.EdgeDCommonConst,\\n ScType.Unknown,\\n ScType.EdgeAccessConstPosPerm,\\n self.relAddr)\\n\\n return Iterator(it)\",\n \"def get_next_edge(node: str) -> Iterator[Edge]:\\n if node not in node_to_edges:\\n return\\n yield\\n\\n for edge in node_to_edges[node]:\\n yield edge\",\n \"def incident_edges(self,v,outgoing=True):\\n adj = self._outgoing if outgoing else self._incoming\\n for edge in adj[v].values():\\n yield edge\",\n \"def get_edges(self):\\n return_set = set()\\n for outer_index, outer_list in enumerate(self._adjmatrix):\\n for inner_index, inner_item in enumerate(outer_list):\\n if(inner_item):\\n return_set.add(\\n (self._name[outer_index],\\n self._name[inner_index]))\\n return return_set\",\n \"def getOutEdges(self):\\n edges = []\\n for edict in mm.G[self].values():\\n for k in edict.keys():\\n edges.append(edict.get(k).get(\\\"edge\\\"))\\n \\n return edges\",\n \"def add_all_edges(self):\\n for n1 in self.vertices():\\n for n2 in self.vertices():\\n if n1 != n2:\\n self.add_edge((n1, n2))\",\n \"def iter_edges(self):\\n counter = 0\\n\\n def iterate(node, depth):\\n\\n nonlocal counter\\n no = counter\\n\\n if isinstance(node, Branch):\\n for child in (node.left, node.right):\\n counter += 1\\n yield no, counter, node, child, depth + 1\\n if isinstance(child, Branch):\\n yield from iterate(child, depth=depth + 1)\\n\\n yield None, 0, None, self, 0\\n yield from iterate(self, depth=0)\",\n \"def edges(self):\\n edge_list = []\\n for node1 in self.node_dict:\\n for node2 in self.node_dict[node1]:\\n edge_list.append((node1,\\n node2,\\n self.node_dict[node1][node2]))\\n return edge_list\",\n \"def neighbor_out_iterator(self, vertex):\\n return iter(set(self._backend.iterator_out_nbrs(vertex)))\",\n \"def dfs_iter(self, root):\\n stack = self.dep_graph.out_edges(root)\\n while stack:\\n edge = stack.pop()\\n stack += self.dep_graph.out_edges(edge[1])\\n yield edge\",\n \"def generate_edges(graph):\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\",\n \"def edges(self):\\n bag = set()\\n for v in range(self._V):\\n selfLoops = 0\\n for e in self._adj[v]:\\n if e.other(v) > v:\\n bag.add(e)\\n # only add one copy of each self loop (self loops will be consecutive)\\n elif e.other(v) == v:\\n if selfLoops % 2 == 0: bag.add(e)\\n selfLoops += 1\\n return bag\",\n \"def get_edges(self):\\n return \\\\\\n set({\\n edge\\n for node in self.nodeset\\n for edge in node.get_incident_edges()\\n })\",\n \"def eligible_edges(self):\\n if len(self.edges) == 4:\\n return [self.edges[0], self.edges[2]]\\n return []\",\n \"def test_incoming_edge_traversals(self):\\r\\n e1 = TestEdge.create(self.v1, self.v2, numbers=12)\\r\\n e2 = TestEdge.create(self.v1, self.v3, numbers=13)\\r\\n e3 = OtherTestEdge.create(self.v2, self.v3, numbers=14)\\r\\n\\r\\n results = self.v2.inE()\\r\\n assert len(results) == 1\\r\\n assert e1 in results\\r\\n\\r\\n results = self.v2.inE(types=[OtherTestEdge])\\r\\n assert len(results) == 0\",\n \"def iter_edges(self, edge_uuids=None):\\n\\n if edge_uuids is None:\\n for edge in self._edges.values():\\n yield Edge.from_edge(edge)\\n else:\\n for edge_uuid in edge_uuids:\\n yield Edge.from_edge(self._edges[edge_uuid])\",\n \"def get_eulerian_graph_edges(bbox, source):\\n osm_graph = OSMGraph(bbox, source)\\n # input all nodes and get odd nodes, update node attributes\\n odd_nodes = get_odd_nodes(osm_graph.nodes_dict)\\n\\n # initialize all_pairs_list\\n all_pairs_list = []\\n\\n # if there are 6 or fewer odd nodes look for all possible options,\\n # otherwise look for just three basic pairing options\\n\\n if len(odd_nodes) <= 10:\\n print(\\\"ROBUST PAIRING FUNCTION\\\")\\n all_pairs_list = get_list_of_all_pairs_lists(odd_nodes)\\n\\n else:\\n print(\\\"CHEAP PAIRING FUNCTION\\\")\\n all_pairs_list = get_list_of_all_pairs_lists_short(odd_nodes)\\n\\n for item in all_pairs_list:\\n print(\\\"\\\\n\\\\nPair option:\\\", item)\\n print(\\\"Pair option len:\\\", len(item))\\n\\n dict_pairings_lists_lengths = get_dict_pairings_lists_lengths(\\n all_pairs_list, osm_graph\\n )\\n twice_traversals_edges = get_twice_traversals_edges(dict_pairings_lists_lengths)\\n updated_graph_instance = update_twice_traversal_edges(\\n twice_traversals_edges, osm_graph\\n )\\n return updated_graph_instance\",\n \"def edges( self ):\\n raise NotImplementedError(\\\"edges\\\");\",\n \"def test_get_edges_2(self):\\n G = [[0, [0, 1, 2, 3]], [1, [0, 2]], [2, [0, 1, 3]], [3, [0, 2, 3]]]\\n edges = kargermincut.get_edges(G)\\n edges = kargermincut.remove_self_loops(edges)\\n self.assertEqual(edges, [[0, 1], [0, 2], [0, 3], [1, 2], [2, 3]])\",\n \"def incoming_edge_iterator(self, vertices, labels=True):\\n if vertices is None:\\n vertices = self\\n elif vertices in self:\\n vertices = [vertices]\\n else:\\n vertices = [v for v in vertices if v in self]\\n return self._backend.iterator_in_edges(vertices, labels)\",\n \"def adjacent(self):\\n result = set([v for e in self.edges for v in [e.v1, e.v2]])\\n result.remove(self)\\n return result\",\n \"def test_adjacent_unpresent(graph_with_edges):\\n with pytest.raises(ValueError):\\n graph_with_edges.adjacent('Captain Picard', 'Star Wars')\",\n \"def path2edge(iterable,graph):\\r\\n return (graph.es[graph.get_eid(pair[0],pair[1])] for pair in pairwise(iterable))\",\n \"def _get_non_matched_edges(self):\\n return list(itertools.product(self.coords.values(), self.DIRECTIONS))\",\n \"def _all_edges(node: FMVGraphNode) -> Set[FMVGraphEdge]:\\n rval = set([e for e in node.edges\\n if e.predicate not in skip_fhir_predicates and e.type_node.node not in skip_fhir_types])\\n for p in node.parents:\\n if p.node not in skip_fhir_types:\\n rval.update(FHIROntologyTable._all_edges(p))\\n return rval\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def neighbors_iter(node, topology):\\n return topology[node]\",\n \"def edges(self, node):\\n nID = self.n2ID[node]\\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]\",\n \"def outgoing_edge_iterator(self, vertices, labels=True):\\n if vertices is None:\\n vertices = self\\n elif vertices in self:\\n vertices = [vertices]\\n else:\\n vertices = [v for v in vertices if v in self]\\n return self._backend.iterator_out_edges(vertices, labels)\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def iterate_adjacent(position):\\n return iter(_board_graph[position])\",\n \"def adjacentTo()\\r\\n\\r\\n def fitsWith(self, other):\\r\\n # TODO: Can use list comprehesion??\\r\\n for i, selfEdge in enumerate(self.getEdges()):\\r\\n for j, otherEdge in other.getEdges():\\r\\n if selfEdge.fitsWith(otherEdge):\\r\\n return i, j\\r\\n return False # made it here, so no edge fits together\\r\",\n \"def edges(self):\\n edges = []\\n for key in self:\\n if key:\\n for edge in self[key]:\\n edges.append((key, edge))\\n return edges\",\n \"def edges(adj_mat, vertices):\\n return [(i,j) for i,j in\\n vertices if (i < j and adj_mat[i][j] == 1)]\",\n \"def edgesWithVertices(self):\\n\\n return {e for e in self.edges if not (e.vert1 is None or e.vert2 is None)}\",\n \"def GetInteriorEdgesTri(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesTri()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesTri()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def test_adjacent_none(graph_with_edges):\\n assert graph_with_edges.adjacent('B', 'A') is False\",\n \"def get_edges(self) -> []:\\n graph_edges = []\\n\\n for vertex in self.adj_list:\\n for connection in self.adj_list[vertex]:\\n if (vertex, connection) not in graph_edges and (connection, vertex) not in graph_edges:\\n graph_edges.append((vertex, connection))\\n\\n return graph_edges\",\n \"def get_internal_edges(self):\\n raise NotImplementedError()\",\n \"def edges(self):\\r\\n return [\\r\\n (parent, child)\\r\\n for parent in self._children_of\\r\\n for child in self._children_of[parent]\\r\\n ]\",\n \"def neighbor_in_iterator(self, vertex):\\n return iter(set(self._backend.iterator_in_nbrs(vertex)))\",\n \"def eligible_edges(self):\\n return self.edges\",\n \"def edges(self):\\n edges = []\\n for key in self:\\n if key:\\n for edge in self[key]:\\n edges.append((key, edge, self[key][edge]))\\n return edges\",\n \"def get_right_edges(G,G2):\\n\\tsame_edges,different_edges=set(),set()\\n\\tfor e in G.edges():\\n\\t\\tn1,n2=e\\n\\t\\tif G2.has_edge(n1,n2): same_edges.add(e)\\n\\t\\telse: different_edges.add(e)\\n\\treturn same_edges,different_edges\",\n \"def get_unvisited_neighbours(self, grid):\\n\\t\\tfor neighbour in self.get_neighbours(grid):\\n\\t\\t\\tif not neighbour.visited:\\n\\t\\t\\t\\tyield neighbour\",\n \"def find_boundary(edges):\\n\\n inputs = set([x[0] for x in edges])\\n outputs = set([x[1] for x in edges])\\n for e in edges:\\n inputs.discard(e[1])\\n outputs.discard(e[0])\\n return inputs, outputs\",\n \"def extract_edges(graph):\\n return graph.get_edges()\",\n \"def cw_face_edges(self,face):\\n\\n l0 = self.region_link[face]\\n if face == self.left_region[l0]:\\n l0 = (l0[1], l0[0])\\n l = l0\\n\\n traversing = True\\n edges = []\\n while traversing:\\n edges.append(l)\\n r = self.right_region[l]\\n if r == face:\\n l = self.succ_right[l]\\n else:\\n l = self.succ_left[l]\\n if l == l0:\\n traversing = False\\n return edges\",\n \"def vertices(self):\\n \\n yielded = set()\\n \\n # Iterate over every tuple of edges, e.g. ..., (1, 2), (4, 3), ...\\n for vertices in self.edges():\\n # Iterate over every vertex in the tuple, e.g. ..., 1, 2, 4, 3, ...\\n for vertex in vertices:\\n # Yield if it has not been yielded already\\n if vertex not in yielded:\\n yield vertex\",\n \"def GetInteriorEdgesPent(self):\\n\\n if not isinstance(self.all_edges,np.ndarray):\\n self.GetEdgesPent()\\n if not isinstance(self.edges,np.ndarray):\\n self.GetBoundaryEdgesPent()\\n\\n sorted_all_edges = np.sort(self.all_edges,axis=1)\\n sorted_boundary_edges = np.sort(self.edges,axis=1)\\n\\n x = []\\n for i in range(self.edges.shape[0]):\\n current_sorted_boundary_edge = np.tile(sorted_boundary_edges[i,:],\\n self.all_edges.shape[0]).reshape(self.all_edges.shape[0],self.all_edges.shape[1])\\n interior_edges = np.linalg.norm(current_sorted_boundary_edge - sorted_all_edges,axis=1)\\n pos_interior_edges = np.where(interior_edges==0)[0]\\n if pos_interior_edges.shape[0] != 0:\\n x.append(pos_interior_edges)\\n\\n edge_aranger = np.arange(self.all_edges.shape[0])\\n edge_aranger = np.setdiff1d(edge_aranger,np.array(x)[:,0])\\n interior_edges = self.all_edges[edge_aranger,:]\\n\\n # GET FLAGS FOR BOUNDRAY AND INTERIOR\\n edge_flags = np.ones(self.all_edges.shape[0],dtype=np.int64)\\n edge_flags[edge_aranger] = 0\\n\\n self.interior_edges = interior_edges\\n return interior_edges, edge_flags\",\n \"def iterate_exchanges(self) -> Iterator[ExchangeInterface]:\\n with self.database.conn.read_ctx() as cursor:\\n excluded = self.database.get_settings(cursor).non_syncing_exchanges\\n for exchanges in self.connected_exchanges.values():\\n for exchange in exchanges:\\n # We are not yielding excluded exchanges\\n if exchange.location_id() not in excluded:\\n yield exchange\",\n \"def remove_inconsistent_edges(graph: BELGraph) -> None:\\n for u, v in get_inconsistent_edges(graph):\\n edges = [(u, v, k) for k in graph[u][v]]\\n graph.remove_edges_from(edges)\",\n \"def edges_is_closed_curve(edges):\\n e_prev = first = edges[0]\\n for e in edges[1:]:\\n if e_prev[1] != e[0]:\\n if e_prev[1] == first[0]:\\n # new loop\\n first = e\\n else:\\n return False\\n e_prev = e\\n if e_prev[1] != first[0]:\\n return False\\n return True\",\n \"def __iter__(self) -> Iterable[\\\"AbstractLane\\\"]:\\n for origin in self.graph:\\n for destination in self.graph[origin]:\\n for index, lane in self.graph[origin][destination].items():\\n yield lane\",\n \"def adjacent(self):\\r\\n d = 0\\r\\n while d < 4:\\r\\n a = self.getAdjacent(d)\\r\\n if a is not None:\\r\\n yield a\\r\\n d += 1\",\n \"def edges(self):\\n return self.graph.edges\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7528953","0.7357906","0.7300745","0.7209116","0.71582156","0.69598824","0.6937165","0.69073635","0.69073635","0.67656124","0.6638462","0.66057724","0.65948063","0.6583909","0.6570076","0.6515526","0.64862835","0.648145","0.6469323","0.6456677","0.6452902","0.64440155","0.64223415","0.642203","0.64035773","0.6398602","0.6381775","0.637739","0.636881","0.63573426","0.63362485","0.63274014","0.6316331","0.6308941","0.63021296","0.6295121","0.6283658","0.62832844","0.62749237","0.62731904","0.6269585","0.6269585","0.6269585","0.62688965","0.6267454","0.62453103","0.62429","0.6232142","0.6226573","0.62258047","0.62036294","0.61660284","0.61448574","0.61195284","0.6118218","0.61148596","0.6104552","0.6100606","0.6094277","0.6078807","0.6076331","0.60606384","0.6058916","0.605823","0.6057296","0.60523295","0.60477245","0.6039836","0.6024313","0.6016493","0.60024285","0.59973675","0.5995282","0.59928465","0.59869105","0.59831214","0.5979731","0.59786767","0.59723634","0.59679085","0.59662455","0.59470487","0.59385014","0.5928624","0.5909528","0.59070516","0.58941156","0.58868295","0.58819354","0.5877165","0.5871602","0.58683324","0.5868094","0.5855198","0.5848909","0.58484757","0.58391535","0.5831251","0.5812262","0.580926"],"string":"[\n \"0.7528953\",\n \"0.7357906\",\n \"0.7300745\",\n \"0.7209116\",\n \"0.71582156\",\n \"0.69598824\",\n \"0.6937165\",\n \"0.69073635\",\n \"0.69073635\",\n \"0.67656124\",\n \"0.6638462\",\n \"0.66057724\",\n \"0.65948063\",\n \"0.6583909\",\n \"0.6570076\",\n \"0.6515526\",\n \"0.64862835\",\n \"0.648145\",\n \"0.6469323\",\n \"0.6456677\",\n \"0.6452902\",\n \"0.64440155\",\n \"0.64223415\",\n \"0.642203\",\n \"0.64035773\",\n \"0.6398602\",\n \"0.6381775\",\n \"0.637739\",\n \"0.636881\",\n \"0.63573426\",\n \"0.63362485\",\n \"0.63274014\",\n \"0.6316331\",\n \"0.6308941\",\n \"0.63021296\",\n \"0.6295121\",\n \"0.6283658\",\n \"0.62832844\",\n \"0.62749237\",\n \"0.62731904\",\n \"0.6269585\",\n \"0.6269585\",\n \"0.6269585\",\n \"0.62688965\",\n \"0.6267454\",\n \"0.62453103\",\n \"0.62429\",\n \"0.6232142\",\n \"0.6226573\",\n \"0.62258047\",\n \"0.62036294\",\n \"0.61660284\",\n \"0.61448574\",\n \"0.61195284\",\n \"0.6118218\",\n \"0.61148596\",\n \"0.6104552\",\n \"0.6100606\",\n \"0.6094277\",\n \"0.6078807\",\n \"0.6076331\",\n \"0.60606384\",\n \"0.6058916\",\n \"0.605823\",\n \"0.6057296\",\n \"0.60523295\",\n \"0.60477245\",\n \"0.6039836\",\n \"0.6024313\",\n \"0.6016493\",\n \"0.60024285\",\n \"0.59973675\",\n \"0.5995282\",\n \"0.59928465\",\n \"0.59869105\",\n \"0.59831214\",\n \"0.5979731\",\n \"0.59786767\",\n \"0.59723634\",\n \"0.59679085\",\n \"0.59662455\",\n \"0.59470487\",\n \"0.59385014\",\n \"0.5928624\",\n \"0.5909528\",\n \"0.59070516\",\n \"0.58941156\",\n \"0.58868295\",\n \"0.58819354\",\n \"0.5877165\",\n \"0.5871602\",\n \"0.58683324\",\n \"0.5868094\",\n \"0.5855198\",\n \"0.5848909\",\n \"0.58484757\",\n \"0.58391535\",\n \"0.5831251\",\n \"0.5812262\",\n \"0.580926\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7111966"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":20175,"cells":{"query":{"kind":"string","value":"Iterates over the diseases encountered in edges"},"document":{"kind":"string","value":"def _pathology_iterator(graph):\n for u, v in _iter_pairs(graph):\n if graph.node[u][FUNCTION] == PATHOLOGY:\n yield u\n if graph.node[v][FUNCTION] == PATHOLOGY:\n yield v"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target","def edges(self):\n for e in self._edges:\n yield e","def edges(self):\n return self.dovetails + self.containments + self.internals","def incident_edges(self,v,outgoing=True):\n adj = self._outgoing if outgoing else self._incoming\n for edge in adj[v].values():\n yield edge","def edges_iter(self) -> Generator:\n for u, v, k, data in self.graph.edges(keys=True, data=True):\n yield u, v, k, data","def iterate_edges(\n self, verbs=None, directions=None, nodes=None\n ) -> Iterable[Edge]:","def dfs_iter(self, root):\n stack = self.dep_graph.out_edges(root)\n while stack:\n edge = stack.pop()\n stack += self.dep_graph.out_edges(edge[1])\n yield edge","def visitEdges(self) -> None:\n\n for node in self.nodesMap_.values():\n for nodeInput in node.get_inputs():\n i = nodeInput[0]\n if i.get_name() not in self.nodesMap_:\n print(i.get_kind_name(), i.get_name())\n edgeStr = self.get_unique_vertex_name(i) + \":Outputs -> \"\n edgeStr += self.get_unique_vertex_name(node) + \":Inputs\"\n self.edges_.append(edgeStr)","def _connected_indirect_deviation_edges(self, node):\n return self._connected_edges_predicate(node, self.is_indirect_deviation_edge)","def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for neighbour in self.__graph_dict[node]:\n # Since all edges go both ways, we need only return one of them.\n if {neighbour, node} not in edges:\n edges.append({node, neighbour})\n yield (node, neighbour)","def generate_edges(graph):\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges","def edges(self):\n vertices = self.vertices(closed=True)\n\n for i in range(len(self)):\n yield(vertices[:, i], vertices[:, i+1])","def __generate_edges(self):\n\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append( {vertex,neighbour} )\n return edges","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({vertex, neighbour})\n return edges","def iter_edges(self) -> Iterable[EdgeTuple]:\n # FIXME: handle case where initializing with ddict data from query.\n # If implemented here (adding **d to the edge factory arguments), it\n # will always attempt to update the database on a per-read basis!\n return (\n (u, v, dict(self.edge_attr_dict_factory(self.network, u, v)))\n for u, v, d in self.network.edges.iter_edges()\n )","def edge_decision_from(infr, edges):\n edges = list(edges)\n evidence_decisions = infr.gen_edge_values(\n 'evidence_decision', edges, on_missing='default', default=UNREV\n )\n meta_decisions = infr.gen_edge_values(\n 'meta_decision', edges, on_missing='default', default=NULL\n )\n for ed, md in zip(evidence_decisions, meta_decisions):\n yield _rectify_decision(ed, md)","def __generate_edges(self):\r\n edges = []\r\n for vertex in self.__graph_dict:\r\n for neighbor in self.__graph_dict[vertex]:\r\n if {neighbor, vertex} not in edges:\r\n edges.append({vertex, neighbor})\r\n return edges","def indirect_deviation_edges(self, data=False):\n def predicate(edge, attr):\n return self.is_indirect_deviation_edge(edge)\n\n return self.edges_where_predicate(predicate, data)","def _connected_direct_deviation_edges(self, node):\n return self._connected_edges_predicate(node, self.is_direct_deviation_edge)","def __generate_edges(self):\n edges = []\n for vertex in self.__graph_dict:\n for neighbour in self.__graph_dict[vertex]:\n edges.append({vertex, neighbour})\n return edges","def find_eulerian_cycle(adj_dict, edges):\n if not adj_dict:\n return []\n\n checked = [False] * len(edges)\n list_keys = list(adj_dict.keys())\n for i in list_keys: # the first time will return true anyway\n cycle = []\n if dfs(i, adj_dict, edges, checked, cycle, i):\n return cycle\n return cycle","def __filterEdges(self):","def edges(self):\n bag = set()\n for v in range(self._V):\n selfLoops = 0\n for e in self._adj[v]:\n if e.other(v) > v:\n bag.add(e)\n # only add one copy of each self loop (self loops will be consecutive)\n elif e.other(v) == v:\n if selfLoops % 2 == 0: bag.add(e)\n selfLoops += 1\n return bag","def edges( self ):\n raise NotImplementedError(\"edges\");","def doffsets(self):\n self._flatten()\n for n in self.seq[1:len(self.seq)-1]:\n yield sorted([ d['idx'] - n['idx'] for d in n['edges'] ])\n return","def generate_edges(self):\n for i, n in enumerate(self.points):\n for i1, p in enumerate(self.points[i+1:]):\n d = 0\n differences = 0\n for x in range(3):\n d += math.fabs(n.xyz[x] - p.xyz[x])\n if math.fabs(n.xyz[x] - p.xyz[x]) != 0:\n differences += 1\n\n if differences > 1:\n continue\n\n if d == -1 * self.side_length or d == self.side_length:\n self.edges.append([i, i1 + i + 1])","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if (neighbour, vertex) not in edges:\n edges.append((vertex, neighbour))\n \n for pair in edges:\n for otherpair in edges:\n if pair[1] == otherpair[0]:\n edges.append((pair[0],otherpair[1]))\n return edges","def edges(self):\r\n return self.__generate_edges()","def generate_edges(self):\n edges = []\n for vertex in self.graph_dict:\n for neighbour in self.graph_dict[vertex]:\n if {neighbour, vertex} not in edges:\n edges.append({neighbour, vertex})\n return edges","def edges(self):\n es = []\n for vertex1 in self.vertices():\n for vertex2 in self.out_vertices(vertex1):\n es.append(self[vertex1][vertex2])\n return es","def get_edges(self):\n for i in self.gens:\n if self.active[i]:\n elist = set()\n H = (i,) # edge-stabilizing subgroup\n reps = set(self.word_generator(parabolic=H))\n reps = self.G.sort_words(reps)\n for word in reps:\n v1 = self.G.move(self.vtable, 0, word)\n v2 = self.G.move(self.vtable, 0, word + (i,))\n if v1 is not None and v2 is not None:\n if v1 > v2:\n v1, v2 = v2, v1\n if (v1, v2) not in elist:\n elist.add((v1, v2))\n\n self.edge_indices[i] = elist\n\n self.num_edges = sum(len(L) for L in self.edge_indices.values())","def edges(self, e):\n self._edges = e","def connected_deviation_edges(self, node):\n return self._connected_edges_predicate(node, self.is_deviation_edge)","def edges(self):\n return self.generate_edges()","def direct_deviation_edges(self, data=False):\n def predicate(edge, attr):\n return self.is_direct_deviation_edge(edge)\n\n return self.edges_where_predicate(predicate, data)","def _connected_edges_predicate(self, node, predicate):\n deviation_edges = []\n for edge in self.connected_edges(node):\n if predicate(edge):\n deviation_edges.append(edge)\n return deviation_edges","def extract_edges(graph):\n return graph.get_edges()","def edges(self):\n edges = []\n for key in self._g:\n if self._g[key]:\n for value in self._g[key]:\n edges.append((key, value))\n return edges","def edges(self) -> Set[Tuple[int, int]] : \n edges : Set[Tuple[int, int]] = set()\n for node_id in self.nodes: # iterator over id's\n for adj_node in self.nodes[node_id]:\n edge = (node_id, adj_node)\n if self.directed:\n edges.add(edge)\n else:\n if edge[::-1] not in edges: # if reverse edge not in edges...\n edges.add(edge)\n return edges","def eliminiateEmptyEdges(self, distance = 100):\n print \"Edge elimination started\"\n \n selected_edge_ids = []\n # let us \n \n for point in self.gps_points:\n results = self.idx.nearest(((point.getPoint().x-distance/2), \n (point.getPoint().y-distance/2),\n (point.getPoint().x+distance/2),\n (point.getPoint().y+distance/2)), objects=True)\n for result in results:\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\"nodecounter\"))\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\"nodecounter\"))\n edge_counter = self.G.edge[from_node][to_node].get(\"edgecounter\")\n if edge_counter not in selected_edge_ids:\n selected_edge_ids.append(edge_counter)\n print str(len(selected_edge_ids)) + \" edges found to keep.\"\n \n elimination_counter = 0\n for edge in self.G.edges():\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\"edgecounter\")\n if edgecounter not in selected_edge_ids:\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\"edge\").from_node, self.G.edge[edge[0]][edge[1]].get(\"edge\").to_node)\n self.G.remove_edge(*edge_tuple)\n elimination_counter = elimination_counter + 1\n \n print str(elimination_counter) + \" edges eliminated.\"","def edges(adj_mat, vertices):\n return [(i,j) for i,j in\n vertices if (i < j and adj_mat[i][j] == 1)]","def delete_edges_from(self, edges: Iterable):\n for i, j in edges:\n self.delete_edge(i, j)","def edge_detec(img,sigma_val):\n edges = feature.canny(img, sigma=sigma_val)\n return edges","def edges(self):\n return self.__generate_edges()","def edges(self):\n return self.__generate_edges()","def edges(self):\n return self.__generate_edges()","def iteridents(self):\n raise NotImplementedError","def edge_mapping(self):\n ...","def getOutEdges(self):\n edges = []\n for edict in mm.G[self].values():\n for k in edict.keys():\n edges.append(edict.get(k).get(\"edge\"))\n \n return edges","def edges(self):\n edge_list = []\n for node1 in self.node_dict:\n for node2 in self.node_dict[node1]:\n edge_list.append((node1,\n node2,\n self.node_dict[node1][node2]))\n return edge_list","def edges(self):\n return [(a, b) for a in self._consequences_of\n for b in self._consequences_of[a]]","def find_already_eulerian_cycle(adj_dict, edges):\n if not adj_dict:\n return []\n\n checked = [False] * len(edges)\n list_keys = list(adj_dict.keys())\n for i in list_keys: # the first time will return true anyway\n cycle = [i]\n if dfs_eulerian(i, adj_dict, edges, checked, cycle, i):\n return cycle\n return cycle","def show_edges(self):\n for element in self.graph:\n print(element, self.graph[element])","def number_of_indirect_deviation_edges(self):\n return len(list(self.indirect_deviation_edges()))","def iterate_outbound_edges(self):\n vertex = int(input('enter vertex: '))\n try:\n vertices = self._graph.get_outbound_edges(vertex)\n except ValueError as ve:\n print(ve)\n return\n print('Outbound edges from ' + str(vertex) + ':')\n for v in vertices:\n cost = self._graph.get_cost(vertex, v)\n print('Edge from ' + str(vertex) + ' to ' + str(v) + ' with cost ' + str(cost))","def diseases(self):\n\t\treturn Disease.DiseasesByPatient(self.id, self.host)","def getEdges(self):\n\n return [(cell, vertice) for cell in self.adjacent.keys() for vertice in self.adjacent[cell]]","def edges(self):\n return [(k, val) for k, v in self.dict.iteritems() for val in v]","def dfs_edges_generator(graph, source, reverse=...):\n ...","def edges(self, node):\n nID = self.n2ID[node]\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]","def iter_edges(self):\n yield self.upperleft, self.upperright\n yield self.upperright, self.bottomright\n yield self.bottomright, self.bottomleft\n yield self.bottomleft, self.upperleft","def iter_edges(self):\n yield self.upperleft, self.upperright\n yield self.upperright, self.bottomright\n yield self.bottomright, self.bottomleft\n yield self.bottomleft, self.upperleft","def all_out_edges_of_node(self, id1: int) -> dict:\r\n return self.Edges[id1]","def testDipoleEdge(self):\n\n sources = DipoleFitTaskTest.runDetection(self)\n\n for i, r1 in enumerate(sources):\n result = r1.extract(\"ip_diffim_DipoleFit*\")\n self.assertTrue(result.get(\"ip_diffim_DipoleFit_flag\"))","def path2edge(iterable,graph):\r\n return (graph.es[graph.get_eid(pair[0],pair[1])] for pair in pairwise(iterable))","def iter_edges(self):\n counter = 0\n\n def iterate(node, depth):\n\n nonlocal counter\n no = counter\n\n if isinstance(node, Branch):\n for child in (node.left, node.right):\n counter += 1\n yield no, counter, node, child, depth + 1\n if isinstance(child, Branch):\n yield from iterate(child, depth=depth + 1)\n\n yield None, 0, None, self, 0\n yield from iterate(self, depth=0)","def add_all_edges(self):\n for n1 in self.vertices():\n for n2 in self.vertices():\n if n1 != n2:\n self.add_edge((n1, n2))","def edges(self):\n\t\tleftback = self.center + self.left*self.wr - self.forward*self.hr\n\t\tleftfront = self.center + self.left*self.wr + self.forward*self.hr\n\t\trightfront = self.center - self.left*self.wr + self.forward*self.hr\n\t\trightback = self.center - self.left*self.wr - self.forward*self.hr\n\t\tyield (leftback, leftfront)\n\t\tyield (leftfront, rightfront)\n\t\tyield (rightfront, rightback)\n\t\tyield (rightback, leftback)","def _search_for_edge_ids(path):\n for label in os.listdir(path):\n\n label_path = os.path.join(path, label)\n\n # skip over files because we are only looking for directories.\n if os.path.isfile(label_path):\n continue\n\n # run over all the edge id's that we can find\n # and loading the properties if found.\n for each in os.listdir(label_path):\n try:\n ident = int(each)\n except ValueError:\n logging.error(\n \"%r is not a expected edge id number, skipping edge import\",\n each\n )\n continue\n\n propfile = os.path.join(\n label_path,\n each,\n \"properties.json\"\n )\n\n try:\n head_id = int(\n os.listdir(\n os.path.join(\n label_path,\n each,\n \"head\"\n )\n )[0]\n )\n except ValueError:\n logging.error(\n \"%r is not a expected head id number, skipping edge import\",\n each\n )\n continue\n\n try:\n tail_id = int(\n os.listdir(\n os.path.join(\n label_path,\n each,\n \"tail\"\n )\n )[0]\n )\n except ValueError:\n logging.error(\n \"%r is not a expected tail id number, skipping edge import\",\n each\n )\n continue\n\n yield (\n ident,\n head_id,\n label,\n tail_id,\n propfile if os.path.isfile(propfile) else None\n )","def edge(self, v, d):\n # method here","def disease_descriptors(civic_did8):\n return [civic_did8]","def getEdges(self):\n # for node in graph,\n # return node -> node for j in graph[node]\n\n return [\"->\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]","def find_loops(edges):\n check_regularity(edges)\n loops = []\n edges = edges[:]\n start_i = -1\n last_i = -1\n n = []\n while edges != []:\n if start_i == -1:\n e = edges[0]\n n = [e]\n del edges[0]\n start_i = n[-1][0]\n last_i = n[-1][1]\n else:\n ok = False\n for i, e in enumerate(edges):\n if e[0] == last_i:\n n.append(e)\n del edges[i]\n ok = True\n break\n elif e[1] == last_i:\n n.append((e[1], e[0]))\n del edges[i]\n ok = True\n break\n if not ok:\n if start_i == last_i:\n start_i = -1\n loops.append(n)\n else:\n raise Exception(\"Missing some boundary edge\")\n last_i = n[-1][1]\n if start_i == last_i:\n loops.append(n)\n else:\n raise Exception(\"Missing some boundary edge\")\n return loops","def get_entering_edges(self,node):\n enter_edge_pattern=re.compile('edge_(?P<begin_node>\\w+)_{0}_(?P<iterator>\\w+)'.format(node))\n enter_edges=[]\n for index,edge in enumerate(self.edges):\n if re.match(enter_edge_pattern,edge):\n enter_edges.append(edge)\n return enter_edges","def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v","def E_cycle(adj_dict, num_edges, num_lines):\n\n #current_node = 0 #arbitrarily choose node 0 to start\n\n #set current_node as key in adj_dict when using strings instead of node numbers\n keys = adj_dict.keys()\n current_node = keys[0]\n\n path = []\n seen_edges = 0\n seen_and_extra_edges = [] #for backtracking\n\n while seen_edges != num_edges:\n if len(adj_dict[current_node]) != 0:\n #if there is another outgoing edge\n path.append(current_node)\n next_node = adj_dict[current_node][0] #get the next unseen edge\n adj_dict[current_node].remove(next_node)\n #remove edge so that it won't be visited twice\n if len(adj_dict[current_node]) !=0:\n #if there is another outgoing edge, add it to backtracking list\n seen_and_extra_edges.append(current_node)\n seen_edges +=1\n current_node = next_node\n else:\n #made a bad choice, need to start a new sub-cycle\n #print(seen_and_extra_edges)\n #print(path)\n current_node = seen_and_extra_edges[0]\n seen_and_extra_edges.remove(current_node)\n\n #put the previous sub-cycle into the path\n temp_path = []\n new_start = path.index(current_node)\n temp_path = path[new_start:] #from the restart node to the end\n temp_path += path[:new_start] #from the beginning to the restart node\n path = temp_path\n\n #append the last elt\n source = path[0]\n path+=[source]\n return path","def add_edges_from(self, edges: Iterable):\n for i, j in edges:\n self.add_edge(i, j)","def edges(self):\n edges = []\n for key in self:\n if key:\n for edge in self[key]:\n edges.append((key, edge, self[key][edge]))\n return edges","def number_of_direct_deviation_edges(self):\n return len(list(self.direct_deviation_edges()))","def state_edges(election_result_rows):\r\n\r\n state_edges = {} #Create empty dictionary\r\n for row in election_result_rows: #Iterate through each row\r\n state = row['State'] \r\n edge = row_to_edge(row)\r\n state_edges[state] = edge #Map each state to the democratic edge of the state\r\n\r\n return state_edges #Return the new dictionary \r","def get_gene_disease_pairs(gene_disease_filename, do_mesh_filename):\n random.seed(100) # reproducibility\n gene_disease_df = pd.read_csv(gene_disease_filename, sep=\"\\t\")\n do_mesh_df = pd.read_csv(do_mesh_filename, sep=\"\\t\")\n\n # create doid-mesh list\n do_mesh_pairs = dict(zip(do_mesh_df.doid_code, \"MESH:\" + do_mesh_df.mesh_id))\n gene_disease_df[\"mesh_id\"] = gene_disease_df[\"doid_id\"].replace(do_mesh_pairs)\n # remove rows that don't have a DOID-MESH id mapping\n # gene_disease_df = gene_disease_df.query(\"~mesh_id.str.contains('DOID:')\")\n gene_disease_df = gene_disease_df[~gene_disease_df.mesh_id.str.contains(\"DOID:\")]\n # get positive pairs\n positive_pairs = gene_disease_df[[\"mesh_id\", \"entrez_gene_id\"]].values.tolist()\n\n # randomize pairings to create negative pairs\n gene_disease_df[\"random_gene\"] = random.sample(\n gene_disease_df[\"entrez_gene_id\"].values.tolist(),\n len(gene_disease_df[\"entrez_gene_id\"].values.tolist()),\n )\n randomized_pairs = gene_disease_df[[\"mesh_id\", \"random_gene\"]].values.tolist()\n negative_pairs = []\n for pair in random.sample(randomized_pairs, len(randomized_pairs)):\n if pair not in positive_pairs:\n negative_pairs.append(pair)\n\n # append class to each pair\n for pair in positive_pairs:\n pair.append(1)\n for pair in negative_pairs:\n pair.append(0)\n gene_disease_pairs = positive_pairs + negative_pairs\n\n return gene_disease_pairs","def clean_edges(self):","def real_out_edges_iter (self, node):\n return (data for data in self.network.out_edges_iter(node, data=True)\n if data[2].type in (self.TYPE_LINK_STATIC, self.TYPE_LINK_DYNAMIC))","def graph():\n\n graph = {'A': ['B', 'C'],\n 'B': ['C', 'D'],\n 'C': ['D'],\n 'D': ['C'],\n 'E': ['F'],\n 'F': ['C']}\n\n def generate_edges(graph):\n \"\"\" Convert the dict representation of a graph into a list one\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\n \"\"\"\n edges = []\n\n # for each node in graph\n for node in graph:\n\n # for each neighbour node of a single node\n for neighbour in graph[node]:\n # if edge exists then append\n edges.append((node, neighbour))\n return edges\n\n a = generate_edges(graph=graph)\n print(a)","def _process_edges(self):\n # remove any duplicated edges that may linger.\n self.edge_df = self.edge_df.dropna(subset=['start_id', 'end_id', 'type'])\n # Split the metaedge name from its abbreviation if both are included\n if all(self.edge_df['type'].str.contains('_')):\n e_types = self.edge_df['type'].unique()\n e_types_split = [e.split('_') for e in e_types]\n self.metaedges = [e[-1] for e in e_types_split]\n\n edge_abbrev_dict = {e: abv for e, abv in zip(e_types, self.metaedges)}\n self.edge_df['abbrev'] = self.edge_df['type'].apply(lambda t: edge_abbrev_dict[t])\n\n # %%TODO Ideally all edges should have their abbreviations included, so this should never be run...\n else:\n self.metaedges = self.edge_df['type'].unique()\n self.edge_df['abbrev'] = self.edge_df['type']","def get_exiting_edges(self,node):\n exit_edge_pattern=re.compile('edge_{0}_(?P<end_node>\\w+)_(?P<iterator>\\w+)'.format(node))\n exit_edges=[]\n for index,edge in enumerate(self.edges):\n if re.match(exit_edge_pattern,edge):\n exit_edges.append(edge)\n return exit_edges","def number_of_deviation_edges(self):\n return len(list(self.deviation_edges()))","def iter_edges(self, edge_uuids=None):\n\n if edge_uuids is None:\n for edge in self._edges.values():\n yield Edge.from_edge(edge)\n else:\n for edge_uuid in edge_uuids:\n yield Edge.from_edge(self._edges[edge_uuid])","def dfs_eulerian(i, adj_dict, edges, checked, cycle, start):\n for vertex in adj_dict[i]:\n pos = search_pos(i, vertex, edges, checked)\n if pos != -1:\n checked[pos] = True\n if vertex[0] == start and not (False in checked):\n cycle.append(i)\n return True\n if dfs_eulerian(vertex[0], adj_dict, edges, checked, cycle, start):\n cycle.append(i)\n return True\n checked[pos] = False\n return False","def extract_edge_induced_subgraph(self, predicate):\n # initialize the new nodeset as sets containing disconnected copies of the original nodes\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset()}\n\n # create a null graph using the nodeset constructed above\n G_prime = UndirectedGraph(nodeset)\n\n # for every edge in the original graph\n for edge in self.get_edges():\n if predicate(edge): # if the edge is not filtered out\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\n\n return G_prime # return the subgraph","def four_cycles(graph, vertex):\n count = 0\n for i in range(len(graph[vertex])):\n for j in range(i + 1, (len(graph[vertex]))):\n \tnode1 = graph[vertex][i]\n \tnode2 = graph[vertex][j]\n \tfor neighbour in graph[node2]:\n \t\tif neighbour != vertex and neighbour in graph[node1]:\n \t\t\tcount += 1\n return count","def getSDDCEdgeNodes(proxy_url, sessiontoken, edge_cluster_id,edge_id):\n json_response= get_sddc_edge_nodes_json(proxy_url, sessiontoken, edge_cluster_id)\n if json_response != False:\n edge_path = json_response['results'][edge_id]['path']\n return edge_path\n else:\n return False","def iterative_dfs(starting_vertex, graph):\n starting_vertex.discovered = True\n starting_vertex.discovery_edge = Graph.Edge(starting_vertex, None, None) # Dummy edge\n walk = starting_vertex\n\n while walk is not None:\n has_to_go_back = True\n for edge in graph.incident_edges(walk):\n opposite = edge.opposite(walk)\n if not opposite.discovered:\n opposite.discovered = True\n opposite.discovery_edge = edge\n walk = opposite\n has_to_go_back = False\n break\n\n if has_to_go_back:\n walk = walk.discovery_edge.opposite(walk)\n\n starting_vertex.discovery_edge = None # Remove dummy edge","def regions_from_graph(vertices, edges):\n # step 0 remove filaments (not included in original algorithm)\n nv = np.zeros(len(vertices))\n v = vertices.keys()\n v.sort()\n v2e = {}\n for edge in edges:\n s,e = edge\n nv[v.index(s)] += 1\n nv[v.index(e)] += 1\n v2e[s] = edge\n v2e[e] = edge\n\n filament_nodes = np.nonzero(nv==1)[0]\n filaments = []\n for f in filament_nodes:\n filaments.append(v2e[f])\n edges.remove(v2e[f])\n\n #print filaments\n\n # step 1\n # have a twin for each directed edge\n dedges = edges[:]\n for edge in edges:\n new_edge = edge[1], edge[0]\n if new_edge not in dedges:\n dedges.append( (edge[1],edge[0]) )\n\n # step 2 complement each directed edge with an angle formed with horizontal\n # line passing through edge[0] for each edge\n angles = []\n from math import atan2, degrees\n\n for edge in dedges:\n\n v1 = vertices[edge[0]]\n v2 = vertices[edge[1]]\n dx = v2[0] - v1[0]\n dy = v2[1] - v1[1]\n at = atan2(dy, dx)\n d = degrees(at)\n if d < 0:\n d = 360 + d\n angles.append( [ (edge[0],d), (edge[0],edge[1]) ])\n\n # step 3 sort the list into ascending order using vi and angle as primary and\n # secondary keys\n angles.sort()\n\n\n # form wedges on consecutive entries with same vi (vi,vj,dij), (vi,vk,dik)\n # gives the wedge (vk,vi,vj)\n wedges = []\n start = angles[0]\n c = 0\n for i in range(1,len(angles)):\n next_edge = angles[i]\n previous_edge = angles[i-1]\n if next_edge[0][0] == start[0][0]:\n wedge = [ next_edge[1][1], previous_edge[1][0], previous_edge[1][1] ]\n wedges.append(wedge)\n else:\n # first form wedge with last and first entry of current group\n # to do\n wedge = [ start[1][1], previous_edge[1][0], previous_edge[1][1] ]\n wedges.append(wedge)\n start = next_edge\n\n # final pair\n\n wedge = [ start[1][1], previous_edge[1][0], next_edge[1][1] ]\n wedges.append(wedge)\n\n\n # phase two\n # form regions from contiguous wedges\n\n nw = len(wedges)\n used = [0]*nw\n wedges.sort()\n #print wedges\n\n #print 'forming regions'\n\n i = 0\n regions = []\n while sum(used) < nw:\n i = used.index(0)\n wi = wedges[i]\n start = wedges[i]\n used[i] = 1\n region = [start]\n # find next contiguous wedge for wi\n forming = True\n while forming:\n\n\n # find first wedge contiguous to wi\n for j in xrange(nw):\n wj = wedges[j]\n if wj[0] == wi[1] and wj[1] == wi[2]:\n region.append(wj)\n used[j] = 1\n wi = wj\n if wi[1] == start[0] and wi[2] == start[1]:\n forming = False\n regions.append(region)\n #print start, regions\n #raw_input('h')\n break\n\n # put in closed cartographic form\n nodes = []\n for region in regions:\n wedge0 = [ wedge[0] for wedge in region]\n wedge0.append(wedge0[0])\n nodes.append(wedge0)\n\n results = {}\n results['regions'] = nodes\n results['filaments'] = filaments\n\n return results","def draw_edges(img, data_vertex, data_edges):\r\n i = 0\r\n for v1, v2, v3 in data_edges: # get the numbers of string\r\n # # v1, v2, v3 = v1 - 1, v2 - 1, v3 - 1 # change the numbering\r\n # print(v1,v2,v3)\r\n img = draw_line(img, data_vertex, v1, v2)\r\n img = draw_line(img, data_vertex, v1, v3)\r\n img = draw_line(img, data_vertex, v2, v3)\r\n i += 1\r\n # print(i)\r\n return img","def is_edge_connected_dfs(adj_dict, vertex, edges, check, check_edges):\n check[vertex] = True\n length = len(edges)\n for vert, weigth in adj_dict[vertex]:\n for i in range(length):\n a, b, c = edges[i]\n if (a == vertex and b == vert and c == weigth):\n check_edges[i] = True\n elif (a == vert and b == vertex and c == weigth):\n check_edges[i] = True\n if not check[vert]:\n is_edge_connected_dfs(adj_dict, vert, edges, check, check_edges)","def _handleEdge(self):\r\n if self._aliensdown == False:\r\n for row in self.getAliens():\r\n for alien in row:\r\n if not alien is None:\r\n alien.y -= ALIEN_V_WALK\r\n self._direction = (-1)*self._direction\r\n self._aliensdown = True\r\n else:\r\n for row in self.getAliens():\r\n for alien in row:\r\n if not alien is None:\r\n alien.x += self._direction*ALIEN_H_WALK\r\n self._aliensdown = False","def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\n if include_metadata:\n return iter(\n [\n (e[\"source\"], e[\"target\"], _node_to_metadata(e[\"properties\"]))\n for e in (\n self._g.V()\n .outE()\n .project(\"target\", \"source\", \"properties\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .by(__.valueMap(True))\n .toList()\n )\n ]\n )\n return iter(\n [\n (e[\"source\"], e[\"target\"])\n for e in self._g.V()\n .outE()\n .project(\"target\", \"source\")\n .by(__.inV().values(ID))\n .by(__.outV().values(ID))\n .toList()\n ]\n )","def edges(self, uid):\n\n raise NotImplementedError","def edge_cases():\n pris_edge_cases = {'OHI-': 'Ōi',\n 'ASCO-': 'Ascó',\n 'ROVNO-': 'Rivne',\n 'SHIN-KORI-': 'Kori',\n 'ANO-': 'Arkansas One',\n 'HANBIT-': 'Yeonggwang',\n 'FERMI-': 'Enrico Fermi',\n 'BALTIC-': 'Kaliningrad',\n 'COOK-': 'Donald C. Cook',\n 'HATCH-': 'Edwin I. Hatch',\n 'HARRIS-': 'Shearon Harris',\n 'SHIN-WOLSONG-': 'Wolseong',\n 'ST. ALBAN-': 'Saint-Alban',\n 'LASALLE-': 'LaSalle County',\n 'SUMMER-': 'Virgil C. Summer',\n 'FARLEY-': 'Joseph M. Farley',\n 'ST. LAURENT ': 'Saint-Laurent',\n 'HADDAM NECK': 'Connecticut Yankee',\n 'HIGASHI DORI-1 (TOHOKU)': 'Higashidōri',\n }\n return pris_edge_cases","def generate_edge(self, img):\n rgb_im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n edgearray = self.edge_gen.detectEdges(img/255.0)\n orientationarray = self.edge_gen.computeOrientation(edgearray)\n suppressed_edgearray = self.edge_gen.edgesNms(edgearray, orientationarray)\n return edgearray, orientationarray, suppressed_edgearray"],"string":"[\n \"def iteredges(self):\\n for source, targets in self.successors.items():\\n for target in targets:\\n yield source, target\",\n \"def edges(self):\\n for e in self._edges:\\n yield e\",\n \"def edges(self):\\n return self.dovetails + self.containments + self.internals\",\n \"def incident_edges(self,v,outgoing=True):\\n adj = self._outgoing if outgoing else self._incoming\\n for edge in adj[v].values():\\n yield edge\",\n \"def edges_iter(self) -> Generator:\\n for u, v, k, data in self.graph.edges(keys=True, data=True):\\n yield u, v, k, data\",\n \"def iterate_edges(\\n self, verbs=None, directions=None, nodes=None\\n ) -> Iterable[Edge]:\",\n \"def dfs_iter(self, root):\\n stack = self.dep_graph.out_edges(root)\\n while stack:\\n edge = stack.pop()\\n stack += self.dep_graph.out_edges(edge[1])\\n yield edge\",\n \"def visitEdges(self) -> None:\\n\\n for node in self.nodesMap_.values():\\n for nodeInput in node.get_inputs():\\n i = nodeInput[0]\\n if i.get_name() not in self.nodesMap_:\\n print(i.get_kind_name(), i.get_name())\\n edgeStr = self.get_unique_vertex_name(i) + \\\":Outputs -> \\\"\\n edgeStr += self.get_unique_vertex_name(node) + \\\":Inputs\\\"\\n self.edges_.append(edgeStr)\",\n \"def _connected_indirect_deviation_edges(self, node):\\n return self._connected_edges_predicate(node, self.is_indirect_deviation_edge)\",\n \"def edges(self) -> Iterable[Tuple[Node]]:\\n edges = []\\n for node in self.__graph_dict.keys():\\n for neighbour in self.__graph_dict[node]:\\n # Since all edges go both ways, we need only return one of them.\\n if {neighbour, node} not in edges:\\n edges.append({node, neighbour})\\n yield (node, neighbour)\",\n \"def generate_edges(graph):\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\",\n \"def edges(self):\\n vertices = self.vertices(closed=True)\\n\\n for i in range(len(self)):\\n yield(vertices[:, i], vertices[:, i+1])\",\n \"def __generate_edges(self):\\n\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append( {vertex,neighbour} )\\n return edges\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def iter_edges(self) -> Iterable[EdgeTuple]:\\n # FIXME: handle case where initializing with ddict data from query.\\n # If implemented here (adding **d to the edge factory arguments), it\\n # will always attempt to update the database on a per-read basis!\\n return (\\n (u, v, dict(self.edge_attr_dict_factory(self.network, u, v)))\\n for u, v, d in self.network.edges.iter_edges()\\n )\",\n \"def edge_decision_from(infr, edges):\\n edges = list(edges)\\n evidence_decisions = infr.gen_edge_values(\\n 'evidence_decision', edges, on_missing='default', default=UNREV\\n )\\n meta_decisions = infr.gen_edge_values(\\n 'meta_decision', edges, on_missing='default', default=NULL\\n )\\n for ed, md in zip(evidence_decisions, meta_decisions):\\n yield _rectify_decision(ed, md)\",\n \"def __generate_edges(self):\\r\\n edges = []\\r\\n for vertex in self.__graph_dict:\\r\\n for neighbor in self.__graph_dict[vertex]:\\r\\n if {neighbor, vertex} not in edges:\\r\\n edges.append({vertex, neighbor})\\r\\n return edges\",\n \"def indirect_deviation_edges(self, data=False):\\n def predicate(edge, attr):\\n return self.is_indirect_deviation_edge(edge)\\n\\n return self.edges_where_predicate(predicate, data)\",\n \"def _connected_direct_deviation_edges(self, node):\\n return self._connected_edges_predicate(node, self.is_direct_deviation_edge)\",\n \"def __generate_edges(self):\\n edges = []\\n for vertex in self.__graph_dict:\\n for neighbour in self.__graph_dict[vertex]:\\n edges.append({vertex, neighbour})\\n return edges\",\n \"def find_eulerian_cycle(adj_dict, edges):\\n if not adj_dict:\\n return []\\n\\n checked = [False] * len(edges)\\n list_keys = list(adj_dict.keys())\\n for i in list_keys: # the first time will return true anyway\\n cycle = []\\n if dfs(i, adj_dict, edges, checked, cycle, i):\\n return cycle\\n return cycle\",\n \"def __filterEdges(self):\",\n \"def edges(self):\\n bag = set()\\n for v in range(self._V):\\n selfLoops = 0\\n for e in self._adj[v]:\\n if e.other(v) > v:\\n bag.add(e)\\n # only add one copy of each self loop (self loops will be consecutive)\\n elif e.other(v) == v:\\n if selfLoops % 2 == 0: bag.add(e)\\n selfLoops += 1\\n return bag\",\n \"def edges( self ):\\n raise NotImplementedError(\\\"edges\\\");\",\n \"def doffsets(self):\\n self._flatten()\\n for n in self.seq[1:len(self.seq)-1]:\\n yield sorted([ d['idx'] - n['idx'] for d in n['edges'] ])\\n return\",\n \"def generate_edges(self):\\n for i, n in enumerate(self.points):\\n for i1, p in enumerate(self.points[i+1:]):\\n d = 0\\n differences = 0\\n for x in range(3):\\n d += math.fabs(n.xyz[x] - p.xyz[x])\\n if math.fabs(n.xyz[x] - p.xyz[x]) != 0:\\n differences += 1\\n\\n if differences > 1:\\n continue\\n\\n if d == -1 * self.side_length or d == self.side_length:\\n self.edges.append([i, i1 + i + 1])\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if (neighbour, vertex) not in edges:\\n edges.append((vertex, neighbour))\\n \\n for pair in edges:\\n for otherpair in edges:\\n if pair[1] == otherpair[0]:\\n edges.append((pair[0],otherpair[1]))\\n return edges\",\n \"def edges(self):\\r\\n return self.__generate_edges()\",\n \"def generate_edges(self):\\n edges = []\\n for vertex in self.graph_dict:\\n for neighbour in self.graph_dict[vertex]:\\n if {neighbour, vertex} not in edges:\\n edges.append({neighbour, vertex})\\n return edges\",\n \"def edges(self):\\n es = []\\n for vertex1 in self.vertices():\\n for vertex2 in self.out_vertices(vertex1):\\n es.append(self[vertex1][vertex2])\\n return es\",\n \"def get_edges(self):\\n for i in self.gens:\\n if self.active[i]:\\n elist = set()\\n H = (i,) # edge-stabilizing subgroup\\n reps = set(self.word_generator(parabolic=H))\\n reps = self.G.sort_words(reps)\\n for word in reps:\\n v1 = self.G.move(self.vtable, 0, word)\\n v2 = self.G.move(self.vtable, 0, word + (i,))\\n if v1 is not None and v2 is not None:\\n if v1 > v2:\\n v1, v2 = v2, v1\\n if (v1, v2) not in elist:\\n elist.add((v1, v2))\\n\\n self.edge_indices[i] = elist\\n\\n self.num_edges = sum(len(L) for L in self.edge_indices.values())\",\n \"def edges(self, e):\\n self._edges = e\",\n \"def connected_deviation_edges(self, node):\\n return self._connected_edges_predicate(node, self.is_deviation_edge)\",\n \"def edges(self):\\n return self.generate_edges()\",\n \"def direct_deviation_edges(self, data=False):\\n def predicate(edge, attr):\\n return self.is_direct_deviation_edge(edge)\\n\\n return self.edges_where_predicate(predicate, data)\",\n \"def _connected_edges_predicate(self, node, predicate):\\n deviation_edges = []\\n for edge in self.connected_edges(node):\\n if predicate(edge):\\n deviation_edges.append(edge)\\n return deviation_edges\",\n \"def extract_edges(graph):\\n return graph.get_edges()\",\n \"def edges(self):\\n edges = []\\n for key in self._g:\\n if self._g[key]:\\n for value in self._g[key]:\\n edges.append((key, value))\\n return edges\",\n \"def edges(self) -> Set[Tuple[int, int]] : \\n edges : Set[Tuple[int, int]] = set()\\n for node_id in self.nodes: # iterator over id's\\n for adj_node in self.nodes[node_id]:\\n edge = (node_id, adj_node)\\n if self.directed:\\n edges.add(edge)\\n else:\\n if edge[::-1] not in edges: # if reverse edge not in edges...\\n edges.add(edge)\\n return edges\",\n \"def eliminiateEmptyEdges(self, distance = 100):\\n print \\\"Edge elimination started\\\"\\n \\n selected_edge_ids = []\\n # let us \\n \\n for point in self.gps_points:\\n results = self.idx.nearest(((point.getPoint().x-distance/2), \\n (point.getPoint().y-distance/2),\\n (point.getPoint().x+distance/2),\\n (point.getPoint().y+distance/2)), objects=True)\\n for result in results:\\n from_node = self.node_counter__node.get(result.object.from_node.getAttributes().get(\\\"nodecounter\\\"))\\n to_node = self.node_counter__node.get(result.object.to_node.getAttributes().get(\\\"nodecounter\\\"))\\n edge_counter = self.G.edge[from_node][to_node].get(\\\"edgecounter\\\")\\n if edge_counter not in selected_edge_ids:\\n selected_edge_ids.append(edge_counter)\\n print str(len(selected_edge_ids)) + \\\" edges found to keep.\\\"\\n \\n elimination_counter = 0\\n for edge in self.G.edges():\\n edgecounter = self.G.edge[edge[0]][edge[1]].get(\\\"edgecounter\\\")\\n if edgecounter not in selected_edge_ids:\\n edge_tuple = (self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").from_node, self.G.edge[edge[0]][edge[1]].get(\\\"edge\\\").to_node)\\n self.G.remove_edge(*edge_tuple)\\n elimination_counter = elimination_counter + 1\\n \\n print str(elimination_counter) + \\\" edges eliminated.\\\"\",\n \"def edges(adj_mat, vertices):\\n return [(i,j) for i,j in\\n vertices if (i < j and adj_mat[i][j] == 1)]\",\n \"def delete_edges_from(self, edges: Iterable):\\n for i, j in edges:\\n self.delete_edge(i, j)\",\n \"def edge_detec(img,sigma_val):\\n edges = feature.canny(img, sigma=sigma_val)\\n return edges\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def edges(self):\\n return self.__generate_edges()\",\n \"def iteridents(self):\\n raise NotImplementedError\",\n \"def edge_mapping(self):\\n ...\",\n \"def getOutEdges(self):\\n edges = []\\n for edict in mm.G[self].values():\\n for k in edict.keys():\\n edges.append(edict.get(k).get(\\\"edge\\\"))\\n \\n return edges\",\n \"def edges(self):\\n edge_list = []\\n for node1 in self.node_dict:\\n for node2 in self.node_dict[node1]:\\n edge_list.append((node1,\\n node2,\\n self.node_dict[node1][node2]))\\n return edge_list\",\n \"def edges(self):\\n return [(a, b) for a in self._consequences_of\\n for b in self._consequences_of[a]]\",\n \"def find_already_eulerian_cycle(adj_dict, edges):\\n if not adj_dict:\\n return []\\n\\n checked = [False] * len(edges)\\n list_keys = list(adj_dict.keys())\\n for i in list_keys: # the first time will return true anyway\\n cycle = [i]\\n if dfs_eulerian(i, adj_dict, edges, checked, cycle, i):\\n return cycle\\n return cycle\",\n \"def show_edges(self):\\n for element in self.graph:\\n print(element, self.graph[element])\",\n \"def number_of_indirect_deviation_edges(self):\\n return len(list(self.indirect_deviation_edges()))\",\n \"def iterate_outbound_edges(self):\\n vertex = int(input('enter vertex: '))\\n try:\\n vertices = self._graph.get_outbound_edges(vertex)\\n except ValueError as ve:\\n print(ve)\\n return\\n print('Outbound edges from ' + str(vertex) + ':')\\n for v in vertices:\\n cost = self._graph.get_cost(vertex, v)\\n print('Edge from ' + str(vertex) + ' to ' + str(v) + ' with cost ' + str(cost))\",\n \"def diseases(self):\\n\\t\\treturn Disease.DiseasesByPatient(self.id, self.host)\",\n \"def getEdges(self):\\n\\n return [(cell, vertice) for cell in self.adjacent.keys() for vertice in self.adjacent[cell]]\",\n \"def edges(self):\\n return [(k, val) for k, v in self.dict.iteritems() for val in v]\",\n \"def dfs_edges_generator(graph, source, reverse=...):\\n ...\",\n \"def edges(self, node):\\n nID = self.n2ID[node]\\n return [(self.ID2n[n1ID], self.ID2n[n2ID]) for (n1ID, n2ID) in self.G.edges(nID)]\",\n \"def iter_edges(self):\\n yield self.upperleft, self.upperright\\n yield self.upperright, self.bottomright\\n yield self.bottomright, self.bottomleft\\n yield self.bottomleft, self.upperleft\",\n \"def iter_edges(self):\\n yield self.upperleft, self.upperright\\n yield self.upperright, self.bottomright\\n yield self.bottomright, self.bottomleft\\n yield self.bottomleft, self.upperleft\",\n \"def all_out_edges_of_node(self, id1: int) -> dict:\\r\\n return self.Edges[id1]\",\n \"def testDipoleEdge(self):\\n\\n sources = DipoleFitTaskTest.runDetection(self)\\n\\n for i, r1 in enumerate(sources):\\n result = r1.extract(\\\"ip_diffim_DipoleFit*\\\")\\n self.assertTrue(result.get(\\\"ip_diffim_DipoleFit_flag\\\"))\",\n \"def path2edge(iterable,graph):\\r\\n return (graph.es[graph.get_eid(pair[0],pair[1])] for pair in pairwise(iterable))\",\n \"def iter_edges(self):\\n counter = 0\\n\\n def iterate(node, depth):\\n\\n nonlocal counter\\n no = counter\\n\\n if isinstance(node, Branch):\\n for child in (node.left, node.right):\\n counter += 1\\n yield no, counter, node, child, depth + 1\\n if isinstance(child, Branch):\\n yield from iterate(child, depth=depth + 1)\\n\\n yield None, 0, None, self, 0\\n yield from iterate(self, depth=0)\",\n \"def add_all_edges(self):\\n for n1 in self.vertices():\\n for n2 in self.vertices():\\n if n1 != n2:\\n self.add_edge((n1, n2))\",\n \"def edges(self):\\n\\t\\tleftback = self.center + self.left*self.wr - self.forward*self.hr\\n\\t\\tleftfront = self.center + self.left*self.wr + self.forward*self.hr\\n\\t\\trightfront = self.center - self.left*self.wr + self.forward*self.hr\\n\\t\\trightback = self.center - self.left*self.wr - self.forward*self.hr\\n\\t\\tyield (leftback, leftfront)\\n\\t\\tyield (leftfront, rightfront)\\n\\t\\tyield (rightfront, rightback)\\n\\t\\tyield (rightback, leftback)\",\n \"def _search_for_edge_ids(path):\\n for label in os.listdir(path):\\n\\n label_path = os.path.join(path, label)\\n\\n # skip over files because we are only looking for directories.\\n if os.path.isfile(label_path):\\n continue\\n\\n # run over all the edge id's that we can find\\n # and loading the properties if found.\\n for each in os.listdir(label_path):\\n try:\\n ident = int(each)\\n except ValueError:\\n logging.error(\\n \\\"%r is not a expected edge id number, skipping edge import\\\",\\n each\\n )\\n continue\\n\\n propfile = os.path.join(\\n label_path,\\n each,\\n \\\"properties.json\\\"\\n )\\n\\n try:\\n head_id = int(\\n os.listdir(\\n os.path.join(\\n label_path,\\n each,\\n \\\"head\\\"\\n )\\n )[0]\\n )\\n except ValueError:\\n logging.error(\\n \\\"%r is not a expected head id number, skipping edge import\\\",\\n each\\n )\\n continue\\n\\n try:\\n tail_id = int(\\n os.listdir(\\n os.path.join(\\n label_path,\\n each,\\n \\\"tail\\\"\\n )\\n )[0]\\n )\\n except ValueError:\\n logging.error(\\n \\\"%r is not a expected tail id number, skipping edge import\\\",\\n each\\n )\\n continue\\n\\n yield (\\n ident,\\n head_id,\\n label,\\n tail_id,\\n propfile if os.path.isfile(propfile) else None\\n )\",\n \"def edge(self, v, d):\\n # method here\",\n \"def disease_descriptors(civic_did8):\\n return [civic_did8]\",\n \"def getEdges(self):\\n # for node in graph,\\n # return node -> node for j in graph[node]\\n\\n return [\\\"->\\\".join([str(n1), str(n2)]) for n1 in self.graph.keys() for n2 in self.graph[n1]]\",\n \"def find_loops(edges):\\n check_regularity(edges)\\n loops = []\\n edges = edges[:]\\n start_i = -1\\n last_i = -1\\n n = []\\n while edges != []:\\n if start_i == -1:\\n e = edges[0]\\n n = [e]\\n del edges[0]\\n start_i = n[-1][0]\\n last_i = n[-1][1]\\n else:\\n ok = False\\n for i, e in enumerate(edges):\\n if e[0] == last_i:\\n n.append(e)\\n del edges[i]\\n ok = True\\n break\\n elif e[1] == last_i:\\n n.append((e[1], e[0]))\\n del edges[i]\\n ok = True\\n break\\n if not ok:\\n if start_i == last_i:\\n start_i = -1\\n loops.append(n)\\n else:\\n raise Exception(\\\"Missing some boundary edge\\\")\\n last_i = n[-1][1]\\n if start_i == last_i:\\n loops.append(n)\\n else:\\n raise Exception(\\\"Missing some boundary edge\\\")\\n return loops\",\n \"def get_entering_edges(self,node):\\n enter_edge_pattern=re.compile('edge_(?P<begin_node>\\\\w+)_{0}_(?P<iterator>\\\\w+)'.format(node))\\n enter_edges=[]\\n for index,edge in enumerate(self.edges):\\n if re.match(enter_edge_pattern,edge):\\n enter_edges.append(edge)\\n return enter_edges\",\n \"def _iter_pairs(graph):\\n for u, v in set(graph.edges_iter()):\\n yield u, v\",\n \"def E_cycle(adj_dict, num_edges, num_lines):\\n\\n #current_node = 0 #arbitrarily choose node 0 to start\\n\\n #set current_node as key in adj_dict when using strings instead of node numbers\\n keys = adj_dict.keys()\\n current_node = keys[0]\\n\\n path = []\\n seen_edges = 0\\n seen_and_extra_edges = [] #for backtracking\\n\\n while seen_edges != num_edges:\\n if len(adj_dict[current_node]) != 0:\\n #if there is another outgoing edge\\n path.append(current_node)\\n next_node = adj_dict[current_node][0] #get the next unseen edge\\n adj_dict[current_node].remove(next_node)\\n #remove edge so that it won't be visited twice\\n if len(adj_dict[current_node]) !=0:\\n #if there is another outgoing edge, add it to backtracking list\\n seen_and_extra_edges.append(current_node)\\n seen_edges +=1\\n current_node = next_node\\n else:\\n #made a bad choice, need to start a new sub-cycle\\n #print(seen_and_extra_edges)\\n #print(path)\\n current_node = seen_and_extra_edges[0]\\n seen_and_extra_edges.remove(current_node)\\n\\n #put the previous sub-cycle into the path\\n temp_path = []\\n new_start = path.index(current_node)\\n temp_path = path[new_start:] #from the restart node to the end\\n temp_path += path[:new_start] #from the beginning to the restart node\\n path = temp_path\\n\\n #append the last elt\\n source = path[0]\\n path+=[source]\\n return path\",\n \"def add_edges_from(self, edges: Iterable):\\n for i, j in edges:\\n self.add_edge(i, j)\",\n \"def edges(self):\\n edges = []\\n for key in self:\\n if key:\\n for edge in self[key]:\\n edges.append((key, edge, self[key][edge]))\\n return edges\",\n \"def number_of_direct_deviation_edges(self):\\n return len(list(self.direct_deviation_edges()))\",\n \"def state_edges(election_result_rows):\\r\\n\\r\\n state_edges = {} #Create empty dictionary\\r\\n for row in election_result_rows: #Iterate through each row\\r\\n state = row['State'] \\r\\n edge = row_to_edge(row)\\r\\n state_edges[state] = edge #Map each state to the democratic edge of the state\\r\\n\\r\\n return state_edges #Return the new dictionary \\r\",\n \"def get_gene_disease_pairs(gene_disease_filename, do_mesh_filename):\\n random.seed(100) # reproducibility\\n gene_disease_df = pd.read_csv(gene_disease_filename, sep=\\\"\\\\t\\\")\\n do_mesh_df = pd.read_csv(do_mesh_filename, sep=\\\"\\\\t\\\")\\n\\n # create doid-mesh list\\n do_mesh_pairs = dict(zip(do_mesh_df.doid_code, \\\"MESH:\\\" + do_mesh_df.mesh_id))\\n gene_disease_df[\\\"mesh_id\\\"] = gene_disease_df[\\\"doid_id\\\"].replace(do_mesh_pairs)\\n # remove rows that don't have a DOID-MESH id mapping\\n # gene_disease_df = gene_disease_df.query(\\\"~mesh_id.str.contains('DOID:')\\\")\\n gene_disease_df = gene_disease_df[~gene_disease_df.mesh_id.str.contains(\\\"DOID:\\\")]\\n # get positive pairs\\n positive_pairs = gene_disease_df[[\\\"mesh_id\\\", \\\"entrez_gene_id\\\"]].values.tolist()\\n\\n # randomize pairings to create negative pairs\\n gene_disease_df[\\\"random_gene\\\"] = random.sample(\\n gene_disease_df[\\\"entrez_gene_id\\\"].values.tolist(),\\n len(gene_disease_df[\\\"entrez_gene_id\\\"].values.tolist()),\\n )\\n randomized_pairs = gene_disease_df[[\\\"mesh_id\\\", \\\"random_gene\\\"]].values.tolist()\\n negative_pairs = []\\n for pair in random.sample(randomized_pairs, len(randomized_pairs)):\\n if pair not in positive_pairs:\\n negative_pairs.append(pair)\\n\\n # append class to each pair\\n for pair in positive_pairs:\\n pair.append(1)\\n for pair in negative_pairs:\\n pair.append(0)\\n gene_disease_pairs = positive_pairs + negative_pairs\\n\\n return gene_disease_pairs\",\n \"def clean_edges(self):\",\n \"def real_out_edges_iter (self, node):\\n return (data for data in self.network.out_edges_iter(node, data=True)\\n if data[2].type in (self.TYPE_LINK_STATIC, self.TYPE_LINK_DYNAMIC))\",\n \"def graph():\\n\\n graph = {'A': ['B', 'C'],\\n 'B': ['C', 'D'],\\n 'C': ['D'],\\n 'D': ['C'],\\n 'E': ['F'],\\n 'F': ['C']}\\n\\n def generate_edges(graph):\\n \\\"\\\"\\\" Convert the dict representation of a graph into a list one\\n - https://www.geeksforgeeks.org/generate-graph-using-dictionary-python/\\n \\\"\\\"\\\"\\n edges = []\\n\\n # for each node in graph\\n for node in graph:\\n\\n # for each neighbour node of a single node\\n for neighbour in graph[node]:\\n # if edge exists then append\\n edges.append((node, neighbour))\\n return edges\\n\\n a = generate_edges(graph=graph)\\n print(a)\",\n \"def _process_edges(self):\\n # remove any duplicated edges that may linger.\\n self.edge_df = self.edge_df.dropna(subset=['start_id', 'end_id', 'type'])\\n # Split the metaedge name from its abbreviation if both are included\\n if all(self.edge_df['type'].str.contains('_')):\\n e_types = self.edge_df['type'].unique()\\n e_types_split = [e.split('_') for e in e_types]\\n self.metaedges = [e[-1] for e in e_types_split]\\n\\n edge_abbrev_dict = {e: abv for e, abv in zip(e_types, self.metaedges)}\\n self.edge_df['abbrev'] = self.edge_df['type'].apply(lambda t: edge_abbrev_dict[t])\\n\\n # %%TODO Ideally all edges should have their abbreviations included, so this should never be run...\\n else:\\n self.metaedges = self.edge_df['type'].unique()\\n self.edge_df['abbrev'] = self.edge_df['type']\",\n \"def get_exiting_edges(self,node):\\n exit_edge_pattern=re.compile('edge_{0}_(?P<end_node>\\\\w+)_(?P<iterator>\\\\w+)'.format(node))\\n exit_edges=[]\\n for index,edge in enumerate(self.edges):\\n if re.match(exit_edge_pattern,edge):\\n exit_edges.append(edge)\\n return exit_edges\",\n \"def number_of_deviation_edges(self):\\n return len(list(self.deviation_edges()))\",\n \"def iter_edges(self, edge_uuids=None):\\n\\n if edge_uuids is None:\\n for edge in self._edges.values():\\n yield Edge.from_edge(edge)\\n else:\\n for edge_uuid in edge_uuids:\\n yield Edge.from_edge(self._edges[edge_uuid])\",\n \"def dfs_eulerian(i, adj_dict, edges, checked, cycle, start):\\n for vertex in adj_dict[i]:\\n pos = search_pos(i, vertex, edges, checked)\\n if pos != -1:\\n checked[pos] = True\\n if vertex[0] == start and not (False in checked):\\n cycle.append(i)\\n return True\\n if dfs_eulerian(vertex[0], adj_dict, edges, checked, cycle, start):\\n cycle.append(i)\\n return True\\n checked[pos] = False\\n return False\",\n \"def extract_edge_induced_subgraph(self, predicate):\\n # initialize the new nodeset as sets containing disconnected copies of the original nodes\\n nodeset = {node.produce_duplicate_disconnected_node() for node in self.get_nodeset()}\\n\\n # create a null graph using the nodeset constructed above\\n G_prime = UndirectedGraph(nodeset)\\n\\n # for every edge in the original graph\\n for edge in self.get_edges():\\n if predicate(edge): # if the edge is not filtered out\\n G_prime = UndirectedGraph.__induced_subgraph_helper(G_prime, edge)\\n\\n return G_prime # return the subgraph\",\n \"def four_cycles(graph, vertex):\\n count = 0\\n for i in range(len(graph[vertex])):\\n for j in range(i + 1, (len(graph[vertex]))):\\n \\tnode1 = graph[vertex][i]\\n \\tnode2 = graph[vertex][j]\\n \\tfor neighbour in graph[node2]:\\n \\t\\tif neighbour != vertex and neighbour in graph[node1]:\\n \\t\\t\\tcount += 1\\n return count\",\n \"def getSDDCEdgeNodes(proxy_url, sessiontoken, edge_cluster_id,edge_id):\\n json_response= get_sddc_edge_nodes_json(proxy_url, sessiontoken, edge_cluster_id)\\n if json_response != False:\\n edge_path = json_response['results'][edge_id]['path']\\n return edge_path\\n else:\\n return False\",\n \"def iterative_dfs(starting_vertex, graph):\\n starting_vertex.discovered = True\\n starting_vertex.discovery_edge = Graph.Edge(starting_vertex, None, None) # Dummy edge\\n walk = starting_vertex\\n\\n while walk is not None:\\n has_to_go_back = True\\n for edge in graph.incident_edges(walk):\\n opposite = edge.opposite(walk)\\n if not opposite.discovered:\\n opposite.discovered = True\\n opposite.discovery_edge = edge\\n walk = opposite\\n has_to_go_back = False\\n break\\n\\n if has_to_go_back:\\n walk = walk.discovery_edge.opposite(walk)\\n\\n starting_vertex.discovery_edge = None # Remove dummy edge\",\n \"def regions_from_graph(vertices, edges):\\n # step 0 remove filaments (not included in original algorithm)\\n nv = np.zeros(len(vertices))\\n v = vertices.keys()\\n v.sort()\\n v2e = {}\\n for edge in edges:\\n s,e = edge\\n nv[v.index(s)] += 1\\n nv[v.index(e)] += 1\\n v2e[s] = edge\\n v2e[e] = edge\\n\\n filament_nodes = np.nonzero(nv==1)[0]\\n filaments = []\\n for f in filament_nodes:\\n filaments.append(v2e[f])\\n edges.remove(v2e[f])\\n\\n #print filaments\\n\\n # step 1\\n # have a twin for each directed edge\\n dedges = edges[:]\\n for edge in edges:\\n new_edge = edge[1], edge[0]\\n if new_edge not in dedges:\\n dedges.append( (edge[1],edge[0]) )\\n\\n # step 2 complement each directed edge with an angle formed with horizontal\\n # line passing through edge[0] for each edge\\n angles = []\\n from math import atan2, degrees\\n\\n for edge in dedges:\\n\\n v1 = vertices[edge[0]]\\n v2 = vertices[edge[1]]\\n dx = v2[0] - v1[0]\\n dy = v2[1] - v1[1]\\n at = atan2(dy, dx)\\n d = degrees(at)\\n if d < 0:\\n d = 360 + d\\n angles.append( [ (edge[0],d), (edge[0],edge[1]) ])\\n\\n # step 3 sort the list into ascending order using vi and angle as primary and\\n # secondary keys\\n angles.sort()\\n\\n\\n # form wedges on consecutive entries with same vi (vi,vj,dij), (vi,vk,dik)\\n # gives the wedge (vk,vi,vj)\\n wedges = []\\n start = angles[0]\\n c = 0\\n for i in range(1,len(angles)):\\n next_edge = angles[i]\\n previous_edge = angles[i-1]\\n if next_edge[0][0] == start[0][0]:\\n wedge = [ next_edge[1][1], previous_edge[1][0], previous_edge[1][1] ]\\n wedges.append(wedge)\\n else:\\n # first form wedge with last and first entry of current group\\n # to do\\n wedge = [ start[1][1], previous_edge[1][0], previous_edge[1][1] ]\\n wedges.append(wedge)\\n start = next_edge\\n\\n # final pair\\n\\n wedge = [ start[1][1], previous_edge[1][0], next_edge[1][1] ]\\n wedges.append(wedge)\\n\\n\\n # phase two\\n # form regions from contiguous wedges\\n\\n nw = len(wedges)\\n used = [0]*nw\\n wedges.sort()\\n #print wedges\\n\\n #print 'forming regions'\\n\\n i = 0\\n regions = []\\n while sum(used) < nw:\\n i = used.index(0)\\n wi = wedges[i]\\n start = wedges[i]\\n used[i] = 1\\n region = [start]\\n # find next contiguous wedge for wi\\n forming = True\\n while forming:\\n\\n\\n # find first wedge contiguous to wi\\n for j in xrange(nw):\\n wj = wedges[j]\\n if wj[0] == wi[1] and wj[1] == wi[2]:\\n region.append(wj)\\n used[j] = 1\\n wi = wj\\n if wi[1] == start[0] and wi[2] == start[1]:\\n forming = False\\n regions.append(region)\\n #print start, regions\\n #raw_input('h')\\n break\\n\\n # put in closed cartographic form\\n nodes = []\\n for region in regions:\\n wedge0 = [ wedge[0] for wedge in region]\\n wedge0.append(wedge0[0])\\n nodes.append(wedge0)\\n\\n results = {}\\n results['regions'] = nodes\\n results['filaments'] = filaments\\n\\n return results\",\n \"def draw_edges(img, data_vertex, data_edges):\\r\\n i = 0\\r\\n for v1, v2, v3 in data_edges: # get the numbers of string\\r\\n # # v1, v2, v3 = v1 - 1, v2 - 1, v3 - 1 # change the numbering\\r\\n # print(v1,v2,v3)\\r\\n img = draw_line(img, data_vertex, v1, v2)\\r\\n img = draw_line(img, data_vertex, v1, v3)\\r\\n img = draw_line(img, data_vertex, v2, v3)\\r\\n i += 1\\r\\n # print(i)\\r\\n return img\",\n \"def is_edge_connected_dfs(adj_dict, vertex, edges, check, check_edges):\\n check[vertex] = True\\n length = len(edges)\\n for vert, weigth in adj_dict[vertex]:\\n for i in range(length):\\n a, b, c = edges[i]\\n if (a == vertex and b == vert and c == weigth):\\n check_edges[i] = True\\n elif (a == vert and b == vertex and c == weigth):\\n check_edges[i] = True\\n if not check[vert]:\\n is_edge_connected_dfs(adj_dict, vert, edges, check, check_edges)\",\n \"def _handleEdge(self):\\r\\n if self._aliensdown == False:\\r\\n for row in self.getAliens():\\r\\n for alien in row:\\r\\n if not alien is None:\\r\\n alien.y -= ALIEN_V_WALK\\r\\n self._direction = (-1)*self._direction\\r\\n self._aliensdown = True\\r\\n else:\\r\\n for row in self.getAliens():\\r\\n for alien in row:\\r\\n if not alien is None:\\r\\n alien.x += self._direction*ALIEN_H_WALK\\r\\n self._aliensdown = False\",\n \"def all_edges_as_iterable(self, include_metadata: bool = False) -> Generator:\\n if include_metadata:\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"], _node_to_metadata(e[\\\"properties\\\"]))\\n for e in (\\n self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\", \\\"properties\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .by(__.valueMap(True))\\n .toList()\\n )\\n ]\\n )\\n return iter(\\n [\\n (e[\\\"source\\\"], e[\\\"target\\\"])\\n for e in self._g.V()\\n .outE()\\n .project(\\\"target\\\", \\\"source\\\")\\n .by(__.inV().values(ID))\\n .by(__.outV().values(ID))\\n .toList()\\n ]\\n )\",\n \"def edges(self, uid):\\n\\n raise NotImplementedError\",\n \"def edge_cases():\\n pris_edge_cases = {'OHI-': 'Ōi',\\n 'ASCO-': 'Ascó',\\n 'ROVNO-': 'Rivne',\\n 'SHIN-KORI-': 'Kori',\\n 'ANO-': 'Arkansas One',\\n 'HANBIT-': 'Yeonggwang',\\n 'FERMI-': 'Enrico Fermi',\\n 'BALTIC-': 'Kaliningrad',\\n 'COOK-': 'Donald C. Cook',\\n 'HATCH-': 'Edwin I. Hatch',\\n 'HARRIS-': 'Shearon Harris',\\n 'SHIN-WOLSONG-': 'Wolseong',\\n 'ST. ALBAN-': 'Saint-Alban',\\n 'LASALLE-': 'LaSalle County',\\n 'SUMMER-': 'Virgil C. Summer',\\n 'FARLEY-': 'Joseph M. Farley',\\n 'ST. LAURENT ': 'Saint-Laurent',\\n 'HADDAM NECK': 'Connecticut Yankee',\\n 'HIGASHI DORI-1 (TOHOKU)': 'Higashidōri',\\n }\\n return pris_edge_cases\",\n \"def generate_edge(self, img):\\n rgb_im = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n edgearray = self.edge_gen.detectEdges(img/255.0)\\n orientationarray = self.edge_gen.computeOrientation(edgearray)\\n suppressed_edgearray = self.edge_gen.edgesNms(edgearray, orientationarray)\\n return edgearray, orientationarray, suppressed_edgearray\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6399897","0.6153952","0.61008126","0.60606647","0.6040917","0.59607315","0.5926328","0.5895811","0.5892186","0.5819291","0.5712466","0.5706369","0.56961864","0.56956095","0.56910306","0.5677939","0.5674862","0.56623685","0.5655787","0.5648146","0.56472343","0.5639384","0.56304187","0.5605137","0.5599732","0.55971175","0.5586487","0.55811083","0.55789983","0.55552155","0.55275023","0.5519742","0.5514668","0.54805034","0.5478371","0.54493517","0.54435915","0.54224527","0.5415353","0.5410934","0.54077536","0.5406757","0.54046","0.5403276","0.5403276","0.5403276","0.53991616","0.5396677","0.5393105","0.53920233","0.5388173","0.53674203","0.5362692","0.53622615","0.5359309","0.5355277","0.53504354","0.5340836","0.5340132","0.5339448","0.5337101","0.5337101","0.5328484","0.5324045","0.532266","0.53211266","0.532056","0.5304622","0.52950376","0.5278977","0.5264509","0.52605003","0.52511555","0.5243017","0.52342284","0.5224156","0.5223264","0.52141726","0.52086943","0.5205182","0.52050656","0.5203569","0.518668","0.5182482","0.51803315","0.51799923","0.5177578","0.51736426","0.5168876","0.5165986","0.5161567","0.51537144","0.51487094","0.51457727","0.5145631","0.5142821","0.513734","0.5130199","0.51268566","0.51266843","0.51263845"],"string":"[\n \"0.6399897\",\n \"0.6153952\",\n \"0.61008126\",\n \"0.60606647\",\n \"0.6040917\",\n \"0.59607315\",\n \"0.5926328\",\n \"0.5895811\",\n \"0.5892186\",\n \"0.5819291\",\n \"0.5712466\",\n \"0.5706369\",\n \"0.56961864\",\n \"0.56956095\",\n \"0.56910306\",\n \"0.5677939\",\n \"0.5674862\",\n \"0.56623685\",\n \"0.5655787\",\n \"0.5648146\",\n \"0.56472343\",\n \"0.5639384\",\n \"0.56304187\",\n \"0.5605137\",\n \"0.5599732\",\n \"0.55971175\",\n \"0.5586487\",\n \"0.55811083\",\n \"0.55789983\",\n \"0.55552155\",\n \"0.55275023\",\n \"0.5519742\",\n \"0.5514668\",\n \"0.54805034\",\n \"0.5478371\",\n \"0.54493517\",\n \"0.54435915\",\n \"0.54224527\",\n \"0.5415353\",\n \"0.5410934\",\n \"0.54077536\",\n \"0.5406757\",\n \"0.54046\",\n \"0.5403276\",\n \"0.5403276\",\n \"0.5403276\",\n \"0.53991616\",\n \"0.5396677\",\n \"0.5393105\",\n \"0.53920233\",\n \"0.5388173\",\n \"0.53674203\",\n \"0.5362692\",\n \"0.53622615\",\n \"0.5359309\",\n \"0.5355277\",\n \"0.53504354\",\n \"0.5340836\",\n \"0.5340132\",\n \"0.5339448\",\n \"0.5337101\",\n \"0.5337101\",\n \"0.5328484\",\n \"0.5324045\",\n \"0.532266\",\n \"0.53211266\",\n \"0.532056\",\n \"0.5304622\",\n \"0.52950376\",\n \"0.5278977\",\n \"0.5264509\",\n \"0.52605003\",\n \"0.52511555\",\n \"0.5243017\",\n \"0.52342284\",\n \"0.5224156\",\n \"0.5223264\",\n \"0.52141726\",\n \"0.52086943\",\n \"0.5205182\",\n \"0.52050656\",\n \"0.5203569\",\n \"0.518668\",\n \"0.5182482\",\n \"0.51803315\",\n \"0.51799923\",\n \"0.5177578\",\n \"0.51736426\",\n \"0.5168876\",\n \"0.5165986\",\n \"0.5161567\",\n \"0.51537144\",\n \"0.51487094\",\n \"0.51457727\",\n \"0.5145631\",\n \"0.5142821\",\n \"0.513734\",\n \"0.5130199\",\n \"0.51268566\",\n \"0.51266843\",\n \"0.51263845\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20176,"cells":{"query":{"kind":"string","value":"Returns a counter of all of the mentions of pathologies in a network"},"document":{"kind":"string","value":"def count_pathologies(graph):\n return Counter(_pathology_iterator(graph))"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )","def num_links(self):\n count=0.0\n for cluster in self.clusters:\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\n numberofmembers=self.clusters[cluster].number_of_members\n count+=numberofmembers\n return count","def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))","def count_selfloop_mates(node,bamfile,G):\n off_node_count = 0\n on_node_count = 0\n if node[-1] == \"'\": node = node[:-1]\n try:\n for hit in bamfile.fetch(node):\n nref = bamfile.getrname(hit.next_reference_id)\n if nref != node:\n off_node_count += 1\n else: on_node_count += 1\n\n except ValueError:\n pass\n\n return off_node_count, on_node_count","def treeThreat():\n\tglobal treeThreatList\n\ttreeThreatList = []\n\tcount = 0\n\tfor name in threatList:\n\t\tif name in treeList:\n\t\t\tcount += 1\n\t\t\ttreeThreatList.append(name)\n\treturn count","def countTotalDistance(path):\n current = path[0]\n totalDistance = 0\n\n for node in path[1:]:\n totalDistance += distance_func(current, node)\n current = node\n\n return totalDistance","def get_stats(sents):\n import os\n import re \n # first, put the relevant trees into temp file\n if 'outname' in kwargs.keys():\n to_open = 'tmp-%s.txt' % kwargs['outname']\n else:\n to_open = 'tmp.txt'\n with open(to_open, \"w\") as fo:\n for sent in sents:\n statsmode_results['Sentences'] += 1\n fo.write(sent.parse_string.rstrip().encode('utf-8', errors = 'ignore') + '\\n')\n deps = get_deps(sent, dep_type)\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\n statsmode_results['Passives'] += numpass\n statsmode_results['Tokens'] += len(sent.tokens)\n statsmode_results['Words'] += len([w for w in sent.tokens if w.word.isalnum()])\n #statsmode_results['Unique words'] += len(set([w.word.lower() for w in sent.tokens if w.word.isalnum()]))\n #statsmode_results['Unique lemmata'] += len(set([w.lemma.lower() for w in sent.tokens if w.word.isalnum()]))\n\n # count moods via trees (/\\?/ !< __)\n from dictionaries.process_types import processes\n from corpkit.other import as_regex\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\n #'Open interrogative': r'ROOT < SBARQ <<- (/\\?/ !< __)', \n #'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\?/ !< __))',\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\n 'Open class words': r'/^(NN|JJ|VB|RB)/ < __',\n 'Closed class words': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\n 'Clauses': r'/^S/ < __',\n 'Interrogative': r'ROOT << (/\\?/ !< __)',\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.mental, boundaries = 'w'),\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.verbal, boundaries = 'w'),\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.relational, boundaries = 'w')}\n\n for name, q in sorted(tregex_qs.items()):\n res = tregex_engine(query = q, \n options = ['-o', '-C'], \n corpus = to_open, \n root = root)\n statsmode_results[name] += int(res)\n global numdone\n numdone += 1\n if root:\n root.update()\n if not root:\n tot_string = str(numdone + 1) + '/' + str(total_files * len(tregex_qs.keys()))\n if 'outname' in kwargs.keys():\n tot_string = '%s: %s' % (kwargs['outname'], tot_string)\n animator(p, numdone, tot_string, **par_args)\n if 'note' in kwargs.keys() and kwargs['note'] is not False:\n kwargs['note'].progvar.set((numdone * 100.0 / (total_files * len(tregex_qs.keys())) / denom) + startnum)\n os.remove(to_open)","def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\n return Counter(_naked_names_iter(graph))","def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))","def get_number_of_relations(model):\n if model == None:\n return 0\n counter = 0\n for line in model:\n if line.find('f(2') >= 0:\n counter += 1\n return float(counter)\n #TODO when multiples of same relation, the result is still 1","def get_node_count(self) -> Iterable:\n return self._g.V().count().toList()[0]","def node_count(self) -> int:\n return int(self.graph_tuple_stats.node_count or 0)","def path_length(graph, node_names):\n\n total = 0\n for i in range(0, len(node_names) - 1):\n total += graph.get_edge(node_names[i], node_names[i + 1]).length\n\n return total","def numPaths(self):\n if self.numpaths > -1:\n return self.numpaths\n\n if self.jolt == 0:\n return 1\n\n paths = 0\n for parent in self.parents:\n paths += parent.numPaths()\n \n return paths","def count_relation_doc(document):\n count = {}\n for line in document[1:]:\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\n for relation in relation_types:\n if relation in count:\n count[relation] += 1\n else:\n count[relation] = 1\n return count","def count_nodes(self):\n\t\treturn self.__count_nodes(self)","def graph_count(self) -> int:\n return int(self.graph_tuple_stats.graph_count)","def numNodes(self):\n res = 0\n for n in self.iternodes():\n res += 1\n return res","def count_topologies(self, sample_sets=None) -> tskit.TopologyCounter:\n if sample_sets is None:\n sample_sets = [\n self.tree_sequence.samples(population=pop.id)\n for pop in self.tree_sequence.populations()\n ]\n\n return combinatorics.tree_count_topologies(self, sample_sets)","def count(self):\n\t\treturn len(list(self.nodes))","def __node_rep(self):\n node_list_dict = {}\n for (i, beam) in enumerate(self.beams):\n if str(beam['n1']) not in node_list_dict.keys():\n node_list_dict[str(beam['n1'])] = 1\n else:\n node_list_dict[str(beam['n1'])] += 1\n if str(beam['n2']) not in node_list_dict.keys():\n node_list_dict[str(beam['n2'])] = 1\n else:\n node_list_dict[str(beam['n2'])] += 1\n return node_list_dict","def _num_conn_comp(graph):\n\n return nx.number_connected_components(graph)","def __init__(self, network):\n self.network = network\n self.histogram = [0] * (network.maxDegree() + 1)\n\n for key, node in network.nodes.items():\n self.histogram[node.degree()] += 1\n\n #print(\"Debug: histogram list \", self.histogram)\n\n # Other option:\n # Dict containing {id:degree}\n # self.degrees = {}\n # for node in network.nodes.iteritems():\n # self.degrees[node.identifier] = node.degree()\n # for i in range(0, network.maxDegree() + 1:\n # self.histogram[i] = self.degrees.values().count(i)","def totalConnections(analyzer):\n return model.totalConnections(analyzer)","def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses","def numnems(self):\n count = 0\n for o in self._objs.values():\n count += len(o.netifs())\n return count","def GetNumberOfOnFootConnections(PathInfo):\r\n\tNumberOfOnFootConnections = 0 \r\n\tOnFootGattungList = TrWay.values()\r\n\r\n\tfor ConnInfo in PathInfo:\r\n\t\tgattung = ConnInfo[ConnInfoInd['line_category']]\r\n\t\tif gattung in OnFootGattungList:\r\n\t\t\tNumberOfOnFootConnections += 1 \r\n\treturn NumberOfOnFootConnections","def show_nt_msg(nt):\n\n nt_set = set(nt)\n nt_dict = {}\n\n for nt_node in nt_set:\n nt_dict[nt_node] = len(np.where(nt == nt_node)[0])\n\n return nt_dict","def count_automorphisms(g: Graph) -> int:\n\n def generate_mapping(g: Graph, h: Graph):\n \"\"\"\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\n We map g to h.\n :param g: A graph\n :param h: A graph\n :return: A permutation with the mapping from g to h\n \"\"\"\n mapping = [0] * len(g.vertices)\n for v_g in g:\n for v_h in h:\n if v_g.colornum == v_h.colornum:\n mapping[v_g.label] = v_h.label\n return permutation(len(mapping), mapping=mapping)\n\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\n \"\"\"\n Is called recursively to traverse through the branching tree and to find all automorphisms.\n :param g: A copy of the original graph\n :param h: Another copy of the original graph\n :param d: A list with pre-colored vertices for graph g\n :param i: A list with pre-colored vertices for graph h\n \"\"\"\n\n # Refine the graphs g and h.\n color_refinement([g, h])\n\n # Make sure that the colors are balanced, and check for a bijection.\n if not is_balanced(g, h):\n return\n if is_bijection(g, h):\n\n # Generate the mapping from g -> h.\n p = generate_mapping(g, h)\n\n # If the permutation cannot be generated by this generating set, we need to add it.\n if not is_member(generating_set, p):\n generating_set.append(p)\n\n # We can now back to the last trivial ancestor nodes in the branching tree.\n while [v.label for v in d] != [v.label for v in i]:\n # We remove the vertices from d and i and mark them as 'used'.\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\n d.pop().pre_labeled = True\n i.pop().pre_labeled = True\n\n return\n\n c, next_color = get_c([g, h])\n for v_g in g:\n if v_g.colornum == c:# and not v_g.pre_labeled:\n x = v_g\n break\n\n for v_h in h:\n if v_h.colornum == c and not v_h.pre_labeled:\n g1 = g + Graph(False)\n h1 = h + Graph(False)\n g1.vertices[g.vertices.index(x)].colornum = next_color\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\n d.append(x)\n i.append(v_h)\n generate_automorphisms(g1, h1, d, i)\n\n generating_set = []\n graph_copy_1 = g + Graph(False)\n graph_copy_2 = g + Graph(False)\n for v in graph_copy_1.vertices:\n v.pre_labeled = False\n for v in graph_copy_2.vertices:\n v.pre_labeled = False\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\n return compute_order(generating_set)","def generateNumsets(G):\n # paths = []\n #\n # path = [0]\n # for edge in nx.dfs_edges(G, 0):\n # if edge[0] == path[-1]:\n # path.append(edge[1])\n # else:\n # paths.append(path)\n # search_index = 2\n # while search_index <= len(path):\n # if edge[0] == path[-search_index]:\n # path = path[:-search_index + 1] + [edge[1]]\n # break\n # search_index += 1\n # else:\n # raise Exception(\"Wrong path structure?\", path, edge)\n # paths.append(path)\n # return paths\n\n \"\"\"\n Trying to use itertools LMAO\n \"\"\"\n # paths = []\n #\n # for path in itertools.combinations(G.nodes, 5):\n # paths.append(path)\n # return paths\n\n \"\"\"\n Generating paths using graph\n \"\"\"\n paths = []\n n = len(G.nodes)\n for source in range(n):\n for target in range(source+1, n):\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\n return paths\n\n # return paths","def number_internal_links(self, node_list):\n n_links = self.internal_adjacency(node_list).sum()\n if self.directed:\n return n_links\n else:\n return n_links // 2","def get_lexicon(seg_sents:List[List[str]]) -> Dict[str, int]:\n\tlexicon = {}\n\n\tfor sent in seg_sents:\n\t\tfor word in sent:\n\t\t\tlexicon[word] = lexicon.get(word, 0) + 1\n\t# print(lexicon)\n\treturn lexicon","def find_diameter(self):\n all_ways = []\n for vertex1 in self.graph.keys():\n for vertex2 in self.graph.keys():\n if vertex2 != vertex1:\n result = self.pathFinder(vertex1, vertex2)\n for path in result:\n all_ways.append(len(path) - 1)\n self.diameter = max(all_ways)\n print(f\"Diameter of network is {self.diameter}\")","def __wiki_counts(self):\n\n num_lines = 0\n num_valid_hyperlinks = 0\n disambiguation_ent_errors = 0\n\n print(\"Calculating Wikipedia mention/entity occurrences\")\n\n last_processed_id = -1\n exist_id_found = False\n\n wiki_anchor_files = os.listdir(\n os.path.join(self.base_url, self.wiki_version, \"basic_data/anchor_files/\")\n )\n for wiki_anchor in wiki_anchor_files:\n wiki_file = os.path.join(\n self.base_url,\n self.wiki_version,\n \"basic_data/anchor_files/\",\n wiki_anchor,\n )\n\n with open(wiki_file, \"r\", encoding=\"utf-8\") as f:\n for line in f:\n num_lines += 1\n\n if num_lines % 5000000 == 0:\n print(\n \"Processed {} lines, valid hyperlinks {}\".format(\n num_lines, num_valid_hyperlinks\n )\n )\n if '<doc id=\"' in line:\n id = int(line[line.find(\"id\") + 4 : line.find(\"url\") - 2])\n if id <= last_processed_id:\n exist_id_found = True\n continue\n else:\n exist_id_found = False\n last_processed_id = id\n else:\n if not exist_id_found:\n (\n list_hyp,\n disambiguation_ent_error,\n print_values,\n ) = self.__extract_text_and_hyp(line)\n\n disambiguation_ent_errors += disambiguation_ent_error\n\n for el in list_hyp:\n mention = el[\"mention\"]\n ent_wiki_id = el[\"ent_wikiid\"]\n\n num_valid_hyperlinks += 1\n if mention not in self.wiki_freq:\n self.wiki_freq[mention] = {}\n\n if (\n ent_wiki_id\n in self.wikipedia.wiki_id_name_map[\"ent_id_to_name\"]\n ):\n if mention not in self.mention_freq:\n self.mention_freq[mention] = 0\n self.mention_freq[mention] += 1\n\n ent_name = self.wikipedia.wiki_id_name_map[\n \"ent_id_to_name\"\n ][ent_wiki_id].replace(\" \", \"_\")\n if ent_name not in self.wiki_freq[mention]:\n self.wiki_freq[mention][ent_name] = 0\n self.wiki_freq[mention][ent_name] += 1\n\n print(\n \"Done computing Wikipedia counts. Num valid hyperlinks = {}\".format(\n num_valid_hyperlinks\n )\n )","def get_num_connections(self):\n\n synapses = 0\n for mat in self.weights:\n synapses += mat.size\n return synapses","def test_calculate_count(request):\n print(\"\\n--Starting:\", request.node.name)\n\n net = ModelRoadwayNetwork.read(\n link_file=STPAUL_LINK_FILE,\n node_file=STPAUL_NODE_FILE,\n shape_file=STPAUL_SHAPE_FILE,\n fast=True,\n )\n\n net.add_counts()\n assert \"AADT\" in net.links_df.columns\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\n ## todo write an assert that actually tests something","def size(self):\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))","def get_node_count(self) -> Iterable:\n return len([i for i in self.all_nodes_as_iterable()])","def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\n frame_list = []\n for idx in range(n_proteomes):\n with mailbox_reader(idx) as file_handle:\n frame_list.append(\n pd.read_csv(\n file_handle, sep=\"\\t\", index_col=0\n ).convert_dtypes()\n )\n nodes = pd.concat(\n frame_list,\n ignore_index=True,\n )\n del frame_list\n graph = nx.Graph()\n for unused_tuple, subframe in nodes.groupby(\n by=[\"syn.anchor.id\", \"syn.anchor.sub_id\"]\n ):\n ids = subframe[\"member_ids\"]\n n_ids = len(ids)\n graph.add_nodes_from(ids)\n if n_ids > 1:\n edges = combinations(ids, 2)\n graph.add_edges_from(edges, weight=n_ids)\n outpath = set_path / ANCHORS_FILE\n summarypath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_summary.tsv\"\n )\n histpath = outpath.parent / (\n outpath.name[: -len(outpath.suffix)] + \"_hist.tsv\"\n )\n components = [\n c\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\n if len(c) > 1\n ]\n fh = outpath.open(\"w\")\n fh.write(\"idx\\tcluster_id\\tsize\\tmembers\\n\")\n n_items = 0\n count_list = []\n hash_list = []\n id_list = []\n for i, comp in enumerate(components):\n component = np.sort(pd.Index(list(comp)).to_numpy())\n id_list.append(i)\n size = len(comp)\n count_list.append(size)\n hash_list.append(hash_array(component))\n for node in component:\n fh.write(f\"{n_items}\\t{i}\\t{size}\\t{node}\\n\")\n n_items += 1\n fh.close()\n n_clusts = len(count_list)\n del graph, components\n cluster_counts = pd.DataFrame({\"size\": count_list})\n largest_cluster = cluster_counts[\"size\"].max()\n cluster_hist = (\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\n )\n cluster_hist = cluster_hist.set_index(\"size\")\n cluster_hist = cluster_hist.rename(columns={0: \"n\"})\n cluster_hist[\"item_pct\"] = (\n cluster_hist[\"n\"] * cluster_hist.index * 100.0 / n_items\n )\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n cluster_hist[\"cluster_pct\"] = cluster_hist[\"n\"] * 100.0 / n_clusts\n cluster_hist.to_csv(histpath, sep=\"\\t\", float_format=\"%5.2f\")\n clusters = pd.DataFrame(\n {\"anchor.id\": id_list, \"count\": count_list, \"hash\": hash_list}\n )\n clusters.to_csv(summarypath, sep=\"\\t\")\n stats_dict = {\n \"in_anchor\": n_items,\n \"syn.anchors.n\": n_clusts,\n \"syn.anchors.largest\": largest_cluster,\n }\n return stats_dict","def count_topologies(self, sample_sets=None):\n if sample_sets is None:\n sample_sets = [\n self.samples(population=pop.id) for pop in self.populations()\n ]\n\n yield from combinatorics.treeseq_count_topologies(self, sample_sets)","def count_meme_entries(motif_path):\n with open(motif_path, \"r\") as f:\n counter = 0\n for line in f:\n if line[:6] == \"letter\":\n counter += 1\n return counter","def countNodes(epr):\n result = 1\n argLst = epr.args\n for arg in argLst:\n result += countNodes(arg)\n return result","def result_count(sol,Nt,G):\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq","def test_count_neighbors(self):\n m, n = 5, 5\n k, p = 0.2, 0.7\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\n C = ConwayModel(m, n, k, p, agents)\n\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\n result = C.count_neighbors(to_count)\n self.assertTrue(np.all(expected == result))","def counterCompute(line, nodes, rowname):\n counter = 0\n if nodes != 1: #node has parents \n parent = line[1: nodes] \n for par in parent:\n if (\"Not \" + par) in rowname: #one parent is \"Not par\"\n counter = counter + math.pow(2, nodes - 2 - parent.index(par))\n return counter","def node_count(self):\n return self._node_count","def count(self, nodename: str):\n if nodename in self._d:\n return len(self._d[nodename][0])\n else:\n return 0","def compute_num_nodes(graph):\n return len(graph.keys()) # return the number of nodes in the graph","def ngraphs(self):\n return len(self.__graph_list)","def get_n_share(contig_paths: List[str]) -> dict:\n\n n_share_dict = {}\n seq_dict = {}\n\n for contig_path in contig_paths:\n with open(contig_path, \"r\") as handle:\n for line in handle.read().splitlines():\n if line.startswith(\">\"):\n key = line.replace(\">\", \"\").split(\" \")[0].split(\".\")[0]\n seq_dict[key] = \"\"\n else:\n seq_dict[key] += line\n\n for key, value in seq_dict.items():\n n_share_dict[key] = value.count(\"N\") / len(value)\n\n return n_share_dict","def result_count(sol,Nt,G):\r\n n = G.number_of_nodes()\r\n dict_freq={}\r\n for i in range(n):\r\n k=G.degree(i)\r\n if k not in dict_freq:\r\n dict_freq[k]=sol[Nt,i]\r\n else:\r\n dict_freq[k]+=sol[Nt,i]\r\n return dict_freq","def common_count(self, node_1, node_2):\n return int(len(set(nx.neighbors(self.graph, node_1)).intersection(set(nx.neighbors(self.graph, node_2)))))","def number_of_pathsets(pathset_paths_df):\n return pathset_paths_df[Passenger.TRIP_LIST_COLUMN_TRIP_LIST_ID_NUM].nunique()","def iteridents(self):\n return count(0)","def count_nodes(self, term=None, labels: istr = None) -> int:","def number_of_connectives(formula):\n pass\n # ======== YOUR CODE HERE ========","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def counts(self):\n return sum(self.counter.values()), len(self.visited)","def count_target(self):\n tally = {}\n for obj in self.target:\n tally[obj] = 0\n\n ind = 0\n for label in self.labelList:\n filename = self.pathLabel + label\n f = open(filename, 'r')\n content = f.read().split('\\n')\n for line in content:\n items = line.split(' ')\n if items[0] in self.target:\n tally[items[0]] += 1\n f.close()\n if ind % 100 == 0:\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\n ind += 1\n \n print('[COUNT] done counting targets in dataset')\n print(tally)","def streets_per_node(G):\n spn = dict(nx.get_node_attributes(G, \"street_count\"))\n if set(spn) != set(G.nodes):\n utils.log(\"Graph nodes changed since `street_count`s were calculated\", level=lg.WARN)\n return spn","def average_number(self, target):\r\n #find all shortest paths to target node\r\n lens = nx.shortest_path_length(self.graph, target=target)\r\n path_len = []\r\n #only include paths from actors in list\r\n for i in self.actors:\r\n path_len.append(lens[i]/2)\r\n\r\n #plot histogram\r\n plt.hist(path_len, bins=[i-.5 for i in range(8)])\r\n plt.title(\"Path Length Distribution\")\r\n plt.xlabel(\"Path Length\")\r\n plt.ylabel(\"Occurences\")\r\n plt.show()\r\n\r\n return sum(path_len)/(len(path_len))","def street_segment_count(Gu):\n if nx.is_directed(Gu): # pragma: no cover\n msg = \"`Gu` must be undirected\"\n raise ValueError(msg)\n return len(Gu.edges)","def count_amino_acids(self):\n n = 0\n for chain in self.iter_chains():\n n += chain.count_amino_acids()\n return n","def number_of_walks(G, walk_length):\n import numpy as np\n\n if walk_length < 0:\n raise ValueError(f\"`walk_length` cannot be negative: {walk_length}\")\n\n A = nx.adjacency_matrix(G, weight=None)\n # TODO: Use matrix_power from scipy.sparse when available\n # power = sp.sparse.linalg.matrix_power(A, walk_length)\n power = np.linalg.matrix_power(A.toarray(), walk_length)\n result = {\n u: {v: power[u_idx, v_idx] for v_idx, v in enumerate(G)}\n for u_idx, u in enumerate(G)\n }\n return result","def count():","def findComponents(M: List[List[int]]) -> int:\n G = buildGraph(M)\n U = list(range(len(M)))\n n_components = 0\n while U:\n n_components += 1\n [G, U] = DFS(G, U[0], U)\n return n_components","def number_of_connections(self, asn):\n customer_count = 0\n provider_count = 0\n peer_count = 0\n\n for neighbor in nx.all_neighbors(self, asn):\n edge_data = self.get_edge_data(asn, neighbor)\n if edge_data[\"relationship\"] == -1 and edge_data[\"as1\"] == asn:\n customer_count += 1\n elif edge_data[\"relationship\"] == -1 and edge_data[\"as2\"] == asn:\n provider_count += 1\n elif edge_data[\"relationship\"] == 0:\n peer_count += 1\n return customer_count, provider_count, peer_count","def get_graph_attributes(net_G):\r\n # number of nodes\r\n num_of_nodes = net_G.number_of_nodes()\r\n # number of nodes\r\n num_of_edges = net_G.number_of_edges()\r\n # density of net\r\n net_density = nx.density(net_G)\r\n # maximum degree and average degree\r\n nodes_degree = nx.degree(net_G)\r\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\r\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\r\n # global clustering coefficient: n - count numbers of paths of length two\r\n nodes_triangles = nx.triangles(net_G)\r\n num_of_triangles = sum(nodes_triangles.values())\r\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\r\n n = 0 \r\n for node in pairs_path_length.keys(): \r\n for item in pairs_path_length[node].values():\r\n if item == 2:\r\n n = n + 1\r\n global_clustering_coefficient = (num_of_triangles * 6) / n\r\n # size of giant component\r\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\r\n # return number of edges in graph=graph size\r\n size_of_giant = nx.Graph.size(giant_component)\r\n # calculate the average path length of giant component\r\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\r\n # maximum centrality and average centrality\r\n nodes_centrality = nx.degree_centrality(net_G)\r\n maximum_of_centrality = max(nodes_centrality.values())\r\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\r\n # maximum betweenness centrality\r\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\r\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\r\n # maximum closeness centrality\r\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\r\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\r\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\r\n # summarize graph attributes\r\n graph_attributes = [[\"Number of nodes:\", num_of_nodes], \\\r\n [\"Number of edges:\", num_of_edges], \\\r\n [\"Global clustering coefficient:\", global_clustering_coefficient], \\\r\n [\"Maximum degree:\", maximum_degree], \\\r\n [\"Average degree:\", average_degree], \\\r\n [\"Size of giant component:\", size_of_giant], \\\r\n [\"Average path length:\", average_shortest_path_length],\\\r\n [\"Maximum centrality:\", maximum_of_centrality], \\\r\n [\"Average centrality:\", average_of_centrality],\\\r\n [\"Maximum betweenness centrality:\", maximum_betweenness_centrality],\\\r\n [\"Maximum closeness centrality:\", maximum_closeness_centrality], \\\r\n [\"Average closeness centrality:\", average_closeness_centrality], \\\r\n [\"Net density:\", net_density]]\r\n return graph_attributes","def _MocaCtlGetNodeIDs(self):\n mc = subprocess.Popen([MOCACTL, 'showtbl', '--nodestats'],\n stdout=subprocess.PIPE)\n out, _ = mc.communicate(None)\n nodes = set()\n for line in out.splitlines():\n node = NODE_RE.search(line)\n if node is not None:\n nodes.add(int(node.group(1)))\n node_list = list(nodes)\n length = len(node_list)\n if int(self.AssociatedDeviceCount) != length:\n type(self).AssociatedDeviceCount.Set(self, length)\n return node_list","def get_indegrees(graph: Graph):\n transpose = get_transpose_graph(graph)\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}","def getNeuronCount(self):\n\t\treturn self.loader.getNeuronCount()","def count_nodes(self, term=None, labels: istr = None):","def add_number_of_lemmas(self):\n self.lemmas = 0\n for t in self.thys:\n with open(t, 'r') as f:\n for l in f:\n if l.startswith(\"lemma\") or l.startswith(\"corollary\") or \\\n l.startswith(\"theorem\"):\n self.lemmas += 1","def extract_path_count(self, metapaths=None, start_nodes=None, end_nodes=None, verbose=False, n_jobs=1,\n return_sparse=False, sparse_df=True):\n\n return self._extract_metapath_feaures(metapaths=metapaths, start_nodes=start_nodes, end_nodes=end_nodes,\n verbose=verbose, n_jobs=n_jobs, return_sparse=return_sparse,\n sparse_df=sparse_df, func=mt.count_paths, mats=self.adj_matrices,\n message='Path Count')","def path_length(G, path, weight=\"weight\"):\n length = 0\n u = path[0]\n for v in path[1:]:\n length += G[u][v][weight]\n u = v\n return length","def obstacle_count(self):\n self.wide_scan()\n found_something = False\n counter = 0\n for distance in self.scan:\n if distance and distance < 200 and not found_something:\n found_something = True\n counter += 1\n print(\"Object # %d found, I think\" % counter)\n if distance and distance > 200 and found_something:\n found_something = False\n print(\"\\n----I SEE %d OBJECTS----\\n\" % counter)","def count_paths((min_i, min_j), (max_i, max_j)):\n\n def explore((i, j), path):\n found = 0\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\n if (x, y) == (max_i, max_j):\n found += 1\n debug(\"neighbor %r of node %r on path %r is a goal node: +1\" % ((x, y), (i, j), path))\n elif (x, y) in path: \n debug(\"neighbor %r of node %r already on path %r; ignoring...\" % ((x, y), (i, j), path))\n continue\n else:\n debug(\"neighbor %r of node %r not already on path %r; exploring ...\" % ((x, y), (i, j), path))\n found += explore((x, y), mkpath(path, (x, y)))\n return found\n return explore((0, 0), set([(0, 0)]))","def go_count(self, S_hit, S_go=None):\n c={}\n if S_go is not None: S_go=set(S_go)\n for x in S_hit:\n Y=self.GENE_GO.get(x, [])\n if S_go is not None: Y = set(Y).intersection(S_go)\n for y in Y:\n c[y]=c.get(y,0)+1\n return c","def get_n_chains(self): \n res_id_cnt = 0\n tot_n_res = len(self.res_ids)\n n_chns = 0\n for res_id in self.res_ids:\n res_chn_i = res_id[2]\n if res_id_cnt > 1:\n if res_chn_i == self.res_ids[res_id_cnt-1][2]:\n pass\n else:\n n_chns+=1\n res_id_cnt+=1\n return n_chns","def n(self):\n return sum(list(self.nodes.values()))","def count(self):\n return self.__tree.node_count","def in_degree_distribution (digraph) :\n\n in_degree_dist = dict ()\n in_degrees = compute_in_degrees (digraph)\n\n for node in in_degrees :\n if in_degrees[node] in in_degree_dist :\n in_degree_dist[in_degrees[node]] += 1\n else :\n in_degree_dist[in_degrees[node]] = 1\n\n return in_degree_dist","def joincount(pntGraph, lineGraph, criterion='', threshold=0):\n matNumDict, _ = spatialjoin._spatialjoin(pntGraph, lineGraph, criterion, threshold)\n for edge in lineGraph.edges(data=True):\n edge[2]['joinCount'] = matNumDict[edge[2]['Ind']]\n print('The join count is added to the POLYLINE type graph.')","def nb_simple_paths(self, start, end):\n if start not in self.nodes or end not in self.nodes:\n return None\n\n visited = set()\n nb_paths = 0\n\n def search(node, goal):\n nonlocal nb_paths\n visited.add(node)\n\n if node == goal:\n nb_paths += 1\n else:\n for neighbor in self.nodes[node]:\n if neighbor not in visited:\n search(neighbor, goal)\n\n visited.remove(node)\n\n search(start, end)\n return nb_paths","def number_tokens(dgraph):\n cnt = 0\n for node in dgraph.subgraphs(exclude_root=True):\n node[WORD] = (cnt, node[WORD])\n cnt += 1\n return dgraph","def count_common_connections(network, user_A, user_B):\n count = 0\n if user_A not in network or user_B not in network:\n return False\n for person in network[user_A][0]:\n if person in network[user_B][0]:\n count += 1\n return count","def get_marble_count(self):","def sumoflemmas():\n\n wordnet_length= 74374\n\n wordnet_occurrences = 94949 #not unique words\n \"\"\"stepdown = wn.synsets('entity')[0]\n synsets = downtree.downtree(stepdown, [])\n synsets.append(stepdown)\n synsets = set(synsets)\n #wordnet_length = len(set(synsets))\n\n nameset =[]\n #fdist = FreqDist(brown.words())\n for syn in synsets:\n for lem in syn.lemmas():\n nameset.append(lem.count())\n #nameset.append(lem.name())\n\n # for wh in set(nameset):\n # wordnet_occurrences.append(fdist[wh])\n\n # Should give set of numbers, with which to sum\n\n # wordnet_occurrences = sum(wordnet_occurences)\n\n # Not sure why this returns 105000, seems like a reasonable number,\n # For example, 'dog' returns 70 instead of 42. Perhaps it uses a different\n # percentage of the wordnet corpus. Or was counted wrong. Or this one was,\n # Either way, my understanding is that since we are doing a probability with it,\n # the actual number shouldn't matter too much at these ranges, as long as both the\n # numerator and the denominator are done using the same method.\n\n\n wordnet_occurrences = sum(nameset)\"\"\"\n\n return wordnet_occurrences","def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\n countReferences = {}\n isReferencedBy = {}\n for nt in self.non_terminals: # for each non-terminal in the grammar\n for production in self.grammar[nt]: # for each possible production on that non terminal\n count = {}\n for option in production.split(): # iterate over the production's terms\n count.setdefault(option, 0)\n if option in self.non_terminals: # if the term is a non terminal\n count[option] += 1 # the number of times that option has been referenced increases\n isReferencedBy.setdefault(option, set())\n isReferencedBy[option].add(nt)\n \n for key in count:\n count.setdefault(key, 0)\n countReferences.setdefault(key, {})\n countReferences[key].setdefault(nt, 0)\n\n countReferences[key][nt] = max(\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\n # term is the maximum between all productions in this non terminal\n\n return isReferencedBy, countReferences","def count(self):\r\n return self.count_helper(self.top_node)","def get_mention_counts(articles, skip_nils=True):\n gold_forms=[]\n gold_links=[]\n for example_article in articles:\n for entity in example_article.entity_mentions:\n mention=entity.mention\n meaning=entity.gold_link\n if not skip_nils or meaning!='--NME--':\n gold_forms.append(mention)\n gold_links.append(meaning)\n cnt_instances=Counter(gold_links)\n cnt_forms=Counter(gold_forms)\n return cnt_instances, cnt_forms","def count(self):\n count = {}\n\n for path, lines in self.lines_added.items():\n count[path] = count.get(path, 0) + sum(lines)\n\n for path, lines in self.lines_removed.items():\n count[path] = count.get(path, 0) + sum(lines)\n\n return count","def num_nodes(g):\n return len(g.keys())","def get_stats(sents, **dummy_args):\n from collections import Counter\n statsmode_results = Counter() \n # first, put the relevant trees into temp file\n\n for sent in sents:\n statsmode_results['Sentences'] += 1\n deps = get_deps(sent, dep_type)\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\n statsmode_results['Passives'] += numpass\n statsmode_results['Tokens'] += len(sent.tokens)\n words = [w.word for w in sent.tokens if w.word is not None and w.word.isalnum()]\n statsmode_results['Words'] += len(words)\n statsmode_results['Characters'] += len(''.join(words))\n\n to_open = '\\n'.join(s.parse_string.strip() for s in sents)\n\n from corpkit.dictionaries.process_types import processes\n from corpkit.other import as_regex\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\n 'Open interrogative': r'ROOT < SBARQ <<- (/\\?/ !< __)', \n 'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\?/ !< __))',\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\n 'Open class': r'/^(NN|JJ|VB|RB)/ < __',\n 'Closed class': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\n 'Clauses': r'/^S/ < __',\n 'Interrogative': r'ROOT << (/\\?/ !< __)',\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\n as_regex(processes.mental, boundaries='w'),\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\n as_regex(processes.verbal, boundaries='w'),\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\n as_regex(processes.relational, boundaries='w'),\n 'Verbless clause': r'/^S/ !<< /^VB.?/'}\n\n for name, q in sorted(tregex_qs.items()):\n res = tregex_engine(query=q, \n options=['-o', '-C'], \n corpus=to_open, \n root=root\n )\n statsmode_results[name] += int(res)\n if root:\n root.update()\n return statsmode_results, []","def count_other_citations(pmid,linkname):\n link = f\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\"\n sleep(0.3)\n page = requests.get(link).text\n soup = BeautifulSoup(page, 'html.parser') \n count = int(soup.find_all(attrs={\"name\": \"ncbi_resultcount\"})[0][\"content\"])\n return(count)","def connected_component_statistics(self, printStats=False):\n lengths = self.connected_component_lengths()\n lengthDict = dict(collections.Counter(lengths))\n\n if printStats:\n orderedLengthDict = collections.OrderedDict(sorted(lengthDict.items()))\n numberOfGroups = nx.number_connected_components(self.return_undirected())\n for k, v in orderedLengthDict.iteritems():\n percent = round((100.00*v / numberOfGroups), 2)\n print str(k) + ' nodes: ' + str(v) + ' (' + str(percent) + '%) groups'\n print '-----------------------------------------'\n print 'TOTAL: ' + str(super(SynonymNetwork, self).number_of_nodes()) + ' nodes in network, ' + str(numberOfGroups) + ' distinct groups'\n else:\n return lengthDict","def degree( self, n ):\n return len(self._G.neighbors(n))","def findDiscripancies(taxonomy):\n i = 0\n for entry in taxonomy:\n if entry['parentName'] != None:\n print entry['nodeName']\n if entry['nodeName'].lower() == entry['parentName'].lower():\n i += 1\n print \"No of same nodes = {} \" .format(i)","def extract_number_target_genes(d, g, miranda_fnm):\n\toutput_nm = \"%s_counts.txt\"%(miranda_fnm[:-4])\n\toutput = open(output_nm, 'w')\n\toutput.write(\"miRNA\\ttotal_target_genes\\ttarget_genes_down\\ttarget_genes\\n\")\n\tfor key in d:\n\t\tif len(d[key]) > 0:\n\t\t\t#print key, len(d[key])\n\t\t\toutput.write(\"%s\\t%s\\t%s\\t%s\\n\"%(key, len(d[key]), \n\t\t\t\tlen(g[key]), str(g[key]).strip('[]')))\n\n\toutput.close()","def count_unvisited(data):\n count = sum(n.count(\"n\") for n in data)\n return count"],"string":"[\n \"def count_relations(graph):\\n return Counter(\\n data[RELATION]\\n for _, _, data in graph.edges_iter(data=True)\\n )\",\n \"def num_links(self):\\n count=0.0\\n for cluster in self.clusters:\\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\\n numberofmembers=self.clusters[cluster].number_of_members\\n count+=numberofmembers\\n return count\",\n \"def count_unique_relations(graph):\\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))\",\n \"def count_selfloop_mates(node,bamfile,G):\\n off_node_count = 0\\n on_node_count = 0\\n if node[-1] == \\\"'\\\": node = node[:-1]\\n try:\\n for hit in bamfile.fetch(node):\\n nref = bamfile.getrname(hit.next_reference_id)\\n if nref != node:\\n off_node_count += 1\\n else: on_node_count += 1\\n\\n except ValueError:\\n pass\\n\\n return off_node_count, on_node_count\",\n \"def treeThreat():\\n\\tglobal treeThreatList\\n\\ttreeThreatList = []\\n\\tcount = 0\\n\\tfor name in threatList:\\n\\t\\tif name in treeList:\\n\\t\\t\\tcount += 1\\n\\t\\t\\ttreeThreatList.append(name)\\n\\treturn count\",\n \"def countTotalDistance(path):\\n current = path[0]\\n totalDistance = 0\\n\\n for node in path[1:]:\\n totalDistance += distance_func(current, node)\\n current = node\\n\\n return totalDistance\",\n \"def get_stats(sents):\\n import os\\n import re \\n # first, put the relevant trees into temp file\\n if 'outname' in kwargs.keys():\\n to_open = 'tmp-%s.txt' % kwargs['outname']\\n else:\\n to_open = 'tmp.txt'\\n with open(to_open, \\\"w\\\") as fo:\\n for sent in sents:\\n statsmode_results['Sentences'] += 1\\n fo.write(sent.parse_string.rstrip().encode('utf-8', errors = 'ignore') + '\\\\n')\\n deps = get_deps(sent, dep_type)\\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\\n statsmode_results['Passives'] += numpass\\n statsmode_results['Tokens'] += len(sent.tokens)\\n statsmode_results['Words'] += len([w for w in sent.tokens if w.word.isalnum()])\\n #statsmode_results['Unique words'] += len(set([w.word.lower() for w in sent.tokens if w.word.isalnum()]))\\n #statsmode_results['Unique lemmata'] += len(set([w.lemma.lower() for w in sent.tokens if w.word.isalnum()]))\\n\\n # count moods via trees (/\\\\?/ !< __)\\n from dictionaries.process_types import processes\\n from corpkit.other import as_regex\\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\\n #'Open interrogative': r'ROOT < SBARQ <<- (/\\\\?/ !< __)', \\n #'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\\\?/ !< __))',\\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\\n 'Open class words': r'/^(NN|JJ|VB|RB)/ < __',\\n 'Closed class words': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\\n 'Clauses': r'/^S/ < __',\\n 'Interrogative': r'ROOT << (/\\\\?/ !< __)',\\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.mental, boundaries = 'w'),\\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.verbal, boundaries = 'w'),\\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % as_regex(processes.relational, boundaries = 'w')}\\n\\n for name, q in sorted(tregex_qs.items()):\\n res = tregex_engine(query = q, \\n options = ['-o', '-C'], \\n corpus = to_open, \\n root = root)\\n statsmode_results[name] += int(res)\\n global numdone\\n numdone += 1\\n if root:\\n root.update()\\n if not root:\\n tot_string = str(numdone + 1) + '/' + str(total_files * len(tregex_qs.keys()))\\n if 'outname' in kwargs.keys():\\n tot_string = '%s: %s' % (kwargs['outname'], tot_string)\\n animator(p, numdone, tot_string, **par_args)\\n if 'note' in kwargs.keys() and kwargs['note'] is not False:\\n kwargs['note'].progvar.set((numdone * 100.0 / (total_files * len(tregex_qs.keys())) / denom) + startnum)\\n os.remove(to_open)\",\n \"def count_naked_names(graph: BELGraph) -> typing.Counter[str]:\\n return Counter(_naked_names_iter(graph))\",\n \"def count_annotations(graph):\\n return Counter(_annotation_iter_helper(graph))\",\n \"def get_number_of_relations(model):\\n if model == None:\\n return 0\\n counter = 0\\n for line in model:\\n if line.find('f(2') >= 0:\\n counter += 1\\n return float(counter)\\n #TODO when multiples of same relation, the result is still 1\",\n \"def get_node_count(self) -> Iterable:\\n return self._g.V().count().toList()[0]\",\n \"def node_count(self) -> int:\\n return int(self.graph_tuple_stats.node_count or 0)\",\n \"def path_length(graph, node_names):\\n\\n total = 0\\n for i in range(0, len(node_names) - 1):\\n total += graph.get_edge(node_names[i], node_names[i + 1]).length\\n\\n return total\",\n \"def numPaths(self):\\n if self.numpaths > -1:\\n return self.numpaths\\n\\n if self.jolt == 0:\\n return 1\\n\\n paths = 0\\n for parent in self.parents:\\n paths += parent.numPaths()\\n \\n return paths\",\n \"def count_relation_doc(document):\\n count = {}\\n for line in document[1:]:\\n _, _, _, relation_types, _ = conll04_parser.split_line(line)\\n for relation in relation_types:\\n if relation in count:\\n count[relation] += 1\\n else:\\n count[relation] = 1\\n return count\",\n \"def count_nodes(self):\\n\\t\\treturn self.__count_nodes(self)\",\n \"def graph_count(self) -> int:\\n return int(self.graph_tuple_stats.graph_count)\",\n \"def numNodes(self):\\n res = 0\\n for n in self.iternodes():\\n res += 1\\n return res\",\n \"def count_topologies(self, sample_sets=None) -> tskit.TopologyCounter:\\n if sample_sets is None:\\n sample_sets = [\\n self.tree_sequence.samples(population=pop.id)\\n for pop in self.tree_sequence.populations()\\n ]\\n\\n return combinatorics.tree_count_topologies(self, sample_sets)\",\n \"def count(self):\\n\\t\\treturn len(list(self.nodes))\",\n \"def __node_rep(self):\\n node_list_dict = {}\\n for (i, beam) in enumerate(self.beams):\\n if str(beam['n1']) not in node_list_dict.keys():\\n node_list_dict[str(beam['n1'])] = 1\\n else:\\n node_list_dict[str(beam['n1'])] += 1\\n if str(beam['n2']) not in node_list_dict.keys():\\n node_list_dict[str(beam['n2'])] = 1\\n else:\\n node_list_dict[str(beam['n2'])] += 1\\n return node_list_dict\",\n \"def _num_conn_comp(graph):\\n\\n return nx.number_connected_components(graph)\",\n \"def __init__(self, network):\\n self.network = network\\n self.histogram = [0] * (network.maxDegree() + 1)\\n\\n for key, node in network.nodes.items():\\n self.histogram[node.degree()] += 1\\n\\n #print(\\\"Debug: histogram list \\\", self.histogram)\\n\\n # Other option:\\n # Dict containing {id:degree}\\n # self.degrees = {}\\n # for node in network.nodes.iteritems():\\n # self.degrees[node.identifier] = node.degree()\\n # for i in range(0, network.maxDegree() + 1:\\n # self.histogram[i] = self.degrees.values().count(i)\",\n \"def totalConnections(analyzer):\\n return model.totalConnections(analyzer)\",\n \"def multiple_connections_histogram(synapses):\\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\\n return count_of_synapses\",\n \"def numnems(self):\\n count = 0\\n for o in self._objs.values():\\n count += len(o.netifs())\\n return count\",\n \"def GetNumberOfOnFootConnections(PathInfo):\\r\\n\\tNumberOfOnFootConnections = 0 \\r\\n\\tOnFootGattungList = TrWay.values()\\r\\n\\r\\n\\tfor ConnInfo in PathInfo:\\r\\n\\t\\tgattung = ConnInfo[ConnInfoInd['line_category']]\\r\\n\\t\\tif gattung in OnFootGattungList:\\r\\n\\t\\t\\tNumberOfOnFootConnections += 1 \\r\\n\\treturn NumberOfOnFootConnections\",\n \"def show_nt_msg(nt):\\n\\n nt_set = set(nt)\\n nt_dict = {}\\n\\n for nt_node in nt_set:\\n nt_dict[nt_node] = len(np.where(nt == nt_node)[0])\\n\\n return nt_dict\",\n \"def count_automorphisms(g: Graph) -> int:\\n\\n def generate_mapping(g: Graph, h: Graph):\\n \\\"\\\"\\\"\\n Generates the corresponding mapping from vertex to vertex for the isomorphism between graphs g and h.\\n We map g to h.\\n :param g: A graph\\n :param h: A graph\\n :return: A permutation with the mapping from g to h\\n \\\"\\\"\\\"\\n mapping = [0] * len(g.vertices)\\n for v_g in g:\\n for v_h in h:\\n if v_g.colornum == v_h.colornum:\\n mapping[v_g.label] = v_h.label\\n return permutation(len(mapping), mapping=mapping)\\n\\n def generate_automorphisms(g: Graph, h: Graph, d: list[Vertex], i: list[Vertex]):\\n \\\"\\\"\\\"\\n Is called recursively to traverse through the branching tree and to find all automorphisms.\\n :param g: A copy of the original graph\\n :param h: Another copy of the original graph\\n :param d: A list with pre-colored vertices for graph g\\n :param i: A list with pre-colored vertices for graph h\\n \\\"\\\"\\\"\\n\\n # Refine the graphs g and h.\\n color_refinement([g, h])\\n\\n # Make sure that the colors are balanced, and check for a bijection.\\n if not is_balanced(g, h):\\n return\\n if is_bijection(g, h):\\n\\n # Generate the mapping from g -> h.\\n p = generate_mapping(g, h)\\n\\n # If the permutation cannot be generated by this generating set, we need to add it.\\n if not is_member(generating_set, p):\\n generating_set.append(p)\\n\\n # We can now back to the last trivial ancestor nodes in the branching tree.\\n while [v.label for v in d] != [v.label for v in i]:\\n # We remove the vertices from d and i and mark them as 'used'.\\n # This should prevent the algorithm from trying to re-explore a branch that may be skipped.\\n # FIXME: This strategy seems too aggressive, the results are sometimes off by a factor 2 or 4\\n d.pop().pre_labeled = True\\n i.pop().pre_labeled = True\\n\\n return\\n\\n c, next_color = get_c([g, h])\\n for v_g in g:\\n if v_g.colornum == c:# and not v_g.pre_labeled:\\n x = v_g\\n break\\n\\n for v_h in h:\\n if v_h.colornum == c and not v_h.pre_labeled:\\n g1 = g + Graph(False)\\n h1 = h + Graph(False)\\n g1.vertices[g.vertices.index(x)].colornum = next_color\\n h1.vertices[h.vertices.index(v_h)].colornum = next_color\\n d.append(x)\\n i.append(v_h)\\n generate_automorphisms(g1, h1, d, i)\\n\\n generating_set = []\\n graph_copy_1 = g + Graph(False)\\n graph_copy_2 = g + Graph(False)\\n for v in graph_copy_1.vertices:\\n v.pre_labeled = False\\n for v in graph_copy_2.vertices:\\n v.pre_labeled = False\\n generate_automorphisms(graph_copy_1, graph_copy_2, [], [])\\n return compute_order(generating_set)\",\n \"def generateNumsets(G):\\n # paths = []\\n #\\n # path = [0]\\n # for edge in nx.dfs_edges(G, 0):\\n # if edge[0] == path[-1]:\\n # path.append(edge[1])\\n # else:\\n # paths.append(path)\\n # search_index = 2\\n # while search_index <= len(path):\\n # if edge[0] == path[-search_index]:\\n # path = path[:-search_index + 1] + [edge[1]]\\n # break\\n # search_index += 1\\n # else:\\n # raise Exception(\\\"Wrong path structure?\\\", path, edge)\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Trying to use itertools LMAO\\n \\\"\\\"\\\"\\n # paths = []\\n #\\n # for path in itertools.combinations(G.nodes, 5):\\n # paths.append(path)\\n # return paths\\n\\n \\\"\\\"\\\"\\n Generating paths using graph\\n \\\"\\\"\\\"\\n paths = []\\n n = len(G.nodes)\\n for source in range(n):\\n for target in range(source+1, n):\\n paths.extend([path for path in nx.all_simple_paths(G, source=source, target=target)])\\n return paths\\n\\n # return paths\",\n \"def number_internal_links(self, node_list):\\n n_links = self.internal_adjacency(node_list).sum()\\n if self.directed:\\n return n_links\\n else:\\n return n_links // 2\",\n \"def get_lexicon(seg_sents:List[List[str]]) -> Dict[str, int]:\\n\\tlexicon = {}\\n\\n\\tfor sent in seg_sents:\\n\\t\\tfor word in sent:\\n\\t\\t\\tlexicon[word] = lexicon.get(word, 0) + 1\\n\\t# print(lexicon)\\n\\treturn lexicon\",\n \"def find_diameter(self):\\n all_ways = []\\n for vertex1 in self.graph.keys():\\n for vertex2 in self.graph.keys():\\n if vertex2 != vertex1:\\n result = self.pathFinder(vertex1, vertex2)\\n for path in result:\\n all_ways.append(len(path) - 1)\\n self.diameter = max(all_ways)\\n print(f\\\"Diameter of network is {self.diameter}\\\")\",\n \"def __wiki_counts(self):\\n\\n num_lines = 0\\n num_valid_hyperlinks = 0\\n disambiguation_ent_errors = 0\\n\\n print(\\\"Calculating Wikipedia mention/entity occurrences\\\")\\n\\n last_processed_id = -1\\n exist_id_found = False\\n\\n wiki_anchor_files = os.listdir(\\n os.path.join(self.base_url, self.wiki_version, \\\"basic_data/anchor_files/\\\")\\n )\\n for wiki_anchor in wiki_anchor_files:\\n wiki_file = os.path.join(\\n self.base_url,\\n self.wiki_version,\\n \\\"basic_data/anchor_files/\\\",\\n wiki_anchor,\\n )\\n\\n with open(wiki_file, \\\"r\\\", encoding=\\\"utf-8\\\") as f:\\n for line in f:\\n num_lines += 1\\n\\n if num_lines % 5000000 == 0:\\n print(\\n \\\"Processed {} lines, valid hyperlinks {}\\\".format(\\n num_lines, num_valid_hyperlinks\\n )\\n )\\n if '<doc id=\\\"' in line:\\n id = int(line[line.find(\\\"id\\\") + 4 : line.find(\\\"url\\\") - 2])\\n if id <= last_processed_id:\\n exist_id_found = True\\n continue\\n else:\\n exist_id_found = False\\n last_processed_id = id\\n else:\\n if not exist_id_found:\\n (\\n list_hyp,\\n disambiguation_ent_error,\\n print_values,\\n ) = self.__extract_text_and_hyp(line)\\n\\n disambiguation_ent_errors += disambiguation_ent_error\\n\\n for el in list_hyp:\\n mention = el[\\\"mention\\\"]\\n ent_wiki_id = el[\\\"ent_wikiid\\\"]\\n\\n num_valid_hyperlinks += 1\\n if mention not in self.wiki_freq:\\n self.wiki_freq[mention] = {}\\n\\n if (\\n ent_wiki_id\\n in self.wikipedia.wiki_id_name_map[\\\"ent_id_to_name\\\"]\\n ):\\n if mention not in self.mention_freq:\\n self.mention_freq[mention] = 0\\n self.mention_freq[mention] += 1\\n\\n ent_name = self.wikipedia.wiki_id_name_map[\\n \\\"ent_id_to_name\\\"\\n ][ent_wiki_id].replace(\\\" \\\", \\\"_\\\")\\n if ent_name not in self.wiki_freq[mention]:\\n self.wiki_freq[mention][ent_name] = 0\\n self.wiki_freq[mention][ent_name] += 1\\n\\n print(\\n \\\"Done computing Wikipedia counts. Num valid hyperlinks = {}\\\".format(\\n num_valid_hyperlinks\\n )\\n )\",\n \"def get_num_connections(self):\\n\\n synapses = 0\\n for mat in self.weights:\\n synapses += mat.size\\n return synapses\",\n \"def test_calculate_count(request):\\n print(\\\"\\\\n--Starting:\\\", request.node.name)\\n\\n net = ModelRoadwayNetwork.read(\\n link_file=STPAUL_LINK_FILE,\\n node_file=STPAUL_NODE_FILE,\\n shape_file=STPAUL_SHAPE_FILE,\\n fast=True,\\n )\\n\\n net.add_counts()\\n assert \\\"AADT\\\" in net.links_df.columns\\n print(net.links_df[net.links_df.drive_access == 1].AADT.value_counts())\\n ## todo write an assert that actually tests something\",\n \"def size(self):\\n return (len(self.nodes), sum([len(x.outgoing_relations) for x in self.nodes.values()]))\",\n \"def get_node_count(self) -> Iterable:\\n return len([i for i in self.all_nodes_as_iterable()])\",\n \"def anchors_to_adjacency(set_path, n_proteomes, mailbox_reader):\\n frame_list = []\\n for idx in range(n_proteomes):\\n with mailbox_reader(idx) as file_handle:\\n frame_list.append(\\n pd.read_csv(\\n file_handle, sep=\\\"\\\\t\\\", index_col=0\\n ).convert_dtypes()\\n )\\n nodes = pd.concat(\\n frame_list,\\n ignore_index=True,\\n )\\n del frame_list\\n graph = nx.Graph()\\n for unused_tuple, subframe in nodes.groupby(\\n by=[\\\"syn.anchor.id\\\", \\\"syn.anchor.sub_id\\\"]\\n ):\\n ids = subframe[\\\"member_ids\\\"]\\n n_ids = len(ids)\\n graph.add_nodes_from(ids)\\n if n_ids > 1:\\n edges = combinations(ids, 2)\\n graph.add_edges_from(edges, weight=n_ids)\\n outpath = set_path / ANCHORS_FILE\\n summarypath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_summary.tsv\\\"\\n )\\n histpath = outpath.parent / (\\n outpath.name[: -len(outpath.suffix)] + \\\"_hist.tsv\\\"\\n )\\n components = [\\n c\\n for c in sorted(nx.connected_components(graph), key=len, reverse=True)\\n if len(c) > 1\\n ]\\n fh = outpath.open(\\\"w\\\")\\n fh.write(\\\"idx\\\\tcluster_id\\\\tsize\\\\tmembers\\\\n\\\")\\n n_items = 0\\n count_list = []\\n hash_list = []\\n id_list = []\\n for i, comp in enumerate(components):\\n component = np.sort(pd.Index(list(comp)).to_numpy())\\n id_list.append(i)\\n size = len(comp)\\n count_list.append(size)\\n hash_list.append(hash_array(component))\\n for node in component:\\n fh.write(f\\\"{n_items}\\\\t{i}\\\\t{size}\\\\t{node}\\\\n\\\")\\n n_items += 1\\n fh.close()\\n n_clusts = len(count_list)\\n del graph, components\\n cluster_counts = pd.DataFrame({\\\"size\\\": count_list})\\n largest_cluster = cluster_counts[\\\"size\\\"].max()\\n cluster_hist = (\\n pd.DataFrame(cluster_counts.value_counts()).sort_index().reset_index()\\n )\\n cluster_hist = cluster_hist.set_index(\\\"size\\\")\\n cluster_hist = cluster_hist.rename(columns={0: \\\"n\\\"})\\n cluster_hist[\\\"item_pct\\\"] = (\\n cluster_hist[\\\"n\\\"] * cluster_hist.index * 100.0 / n_items\\n )\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n cluster_hist[\\\"cluster_pct\\\"] = cluster_hist[\\\"n\\\"] * 100.0 / n_clusts\\n cluster_hist.to_csv(histpath, sep=\\\"\\\\t\\\", float_format=\\\"%5.2f\\\")\\n clusters = pd.DataFrame(\\n {\\\"anchor.id\\\": id_list, \\\"count\\\": count_list, \\\"hash\\\": hash_list}\\n )\\n clusters.to_csv(summarypath, sep=\\\"\\\\t\\\")\\n stats_dict = {\\n \\\"in_anchor\\\": n_items,\\n \\\"syn.anchors.n\\\": n_clusts,\\n \\\"syn.anchors.largest\\\": largest_cluster,\\n }\\n return stats_dict\",\n \"def count_topologies(self, sample_sets=None):\\n if sample_sets is None:\\n sample_sets = [\\n self.samples(population=pop.id) for pop in self.populations()\\n ]\\n\\n yield from combinatorics.treeseq_count_topologies(self, sample_sets)\",\n \"def count_meme_entries(motif_path):\\n with open(motif_path, \\\"r\\\") as f:\\n counter = 0\\n for line in f:\\n if line[:6] == \\\"letter\\\":\\n counter += 1\\n return counter\",\n \"def countNodes(epr):\\n result = 1\\n argLst = epr.args\\n for arg in argLst:\\n result += countNodes(arg)\\n return result\",\n \"def result_count(sol,Nt,G):\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\",\n \"def test_count_neighbors(self):\\n m, n = 5, 5\\n k, p = 0.2, 0.7\\n agents = [ConwayAgent(ii, ii & 0x1 == 1) for ii in range(m * n)]\\n C = ConwayModel(m, n, k, p, agents)\\n\\n to_count = np.array([[0, 1, 0], [0, 0, 1], [1, 0, 0]])\\n expected = np.array([[1, 1, 2], [2, 3, 1], [0, 2, 1]])\\n result = C.count_neighbors(to_count)\\n self.assertTrue(np.all(expected == result))\",\n \"def counterCompute(line, nodes, rowname):\\n counter = 0\\n if nodes != 1: #node has parents \\n parent = line[1: nodes] \\n for par in parent:\\n if (\\\"Not \\\" + par) in rowname: #one parent is \\\"Not par\\\"\\n counter = counter + math.pow(2, nodes - 2 - parent.index(par))\\n return counter\",\n \"def node_count(self):\\n return self._node_count\",\n \"def count(self, nodename: str):\\n if nodename in self._d:\\n return len(self._d[nodename][0])\\n else:\\n return 0\",\n \"def compute_num_nodes(graph):\\n return len(graph.keys()) # return the number of nodes in the graph\",\n \"def ngraphs(self):\\n return len(self.__graph_list)\",\n \"def get_n_share(contig_paths: List[str]) -> dict:\\n\\n n_share_dict = {}\\n seq_dict = {}\\n\\n for contig_path in contig_paths:\\n with open(contig_path, \\\"r\\\") as handle:\\n for line in handle.read().splitlines():\\n if line.startswith(\\\">\\\"):\\n key = line.replace(\\\">\\\", \\\"\\\").split(\\\" \\\")[0].split(\\\".\\\")[0]\\n seq_dict[key] = \\\"\\\"\\n else:\\n seq_dict[key] += line\\n\\n for key, value in seq_dict.items():\\n n_share_dict[key] = value.count(\\\"N\\\") / len(value)\\n\\n return n_share_dict\",\n \"def result_count(sol,Nt,G):\\r\\n n = G.number_of_nodes()\\r\\n dict_freq={}\\r\\n for i in range(n):\\r\\n k=G.degree(i)\\r\\n if k not in dict_freq:\\r\\n dict_freq[k]=sol[Nt,i]\\r\\n else:\\r\\n dict_freq[k]+=sol[Nt,i]\\r\\n return dict_freq\",\n \"def common_count(self, node_1, node_2):\\n return int(len(set(nx.neighbors(self.graph, node_1)).intersection(set(nx.neighbors(self.graph, node_2)))))\",\n \"def number_of_pathsets(pathset_paths_df):\\n return pathset_paths_df[Passenger.TRIP_LIST_COLUMN_TRIP_LIST_ID_NUM].nunique()\",\n \"def iteridents(self):\\n return count(0)\",\n \"def count_nodes(self, term=None, labels: istr = None) -> int:\",\n \"def number_of_connectives(formula):\\n pass\\n # ======== YOUR CODE HERE ========\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def counts(self):\\n return sum(self.counter.values()), len(self.visited)\",\n \"def count_target(self):\\n tally = {}\\n for obj in self.target:\\n tally[obj] = 0\\n\\n ind = 0\\n for label in self.labelList:\\n filename = self.pathLabel + label\\n f = open(filename, 'r')\\n content = f.read().split('\\\\n')\\n for line in content:\\n items = line.split(' ')\\n if items[0] in self.target:\\n tally[items[0]] += 1\\n f.close()\\n if ind % 100 == 0:\\n print(f'[COUNT] {ind} of {len(self.labelList)} processed')\\n ind += 1\\n \\n print('[COUNT] done counting targets in dataset')\\n print(tally)\",\n \"def streets_per_node(G):\\n spn = dict(nx.get_node_attributes(G, \\\"street_count\\\"))\\n if set(spn) != set(G.nodes):\\n utils.log(\\\"Graph nodes changed since `street_count`s were calculated\\\", level=lg.WARN)\\n return spn\",\n \"def average_number(self, target):\\r\\n #find all shortest paths to target node\\r\\n lens = nx.shortest_path_length(self.graph, target=target)\\r\\n path_len = []\\r\\n #only include paths from actors in list\\r\\n for i in self.actors:\\r\\n path_len.append(lens[i]/2)\\r\\n\\r\\n #plot histogram\\r\\n plt.hist(path_len, bins=[i-.5 for i in range(8)])\\r\\n plt.title(\\\"Path Length Distribution\\\")\\r\\n plt.xlabel(\\\"Path Length\\\")\\r\\n plt.ylabel(\\\"Occurences\\\")\\r\\n plt.show()\\r\\n\\r\\n return sum(path_len)/(len(path_len))\",\n \"def street_segment_count(Gu):\\n if nx.is_directed(Gu): # pragma: no cover\\n msg = \\\"`Gu` must be undirected\\\"\\n raise ValueError(msg)\\n return len(Gu.edges)\",\n \"def count_amino_acids(self):\\n n = 0\\n for chain in self.iter_chains():\\n n += chain.count_amino_acids()\\n return n\",\n \"def number_of_walks(G, walk_length):\\n import numpy as np\\n\\n if walk_length < 0:\\n raise ValueError(f\\\"`walk_length` cannot be negative: {walk_length}\\\")\\n\\n A = nx.adjacency_matrix(G, weight=None)\\n # TODO: Use matrix_power from scipy.sparse when available\\n # power = sp.sparse.linalg.matrix_power(A, walk_length)\\n power = np.linalg.matrix_power(A.toarray(), walk_length)\\n result = {\\n u: {v: power[u_idx, v_idx] for v_idx, v in enumerate(G)}\\n for u_idx, u in enumerate(G)\\n }\\n return result\",\n \"def count():\",\n \"def findComponents(M: List[List[int]]) -> int:\\n G = buildGraph(M)\\n U = list(range(len(M)))\\n n_components = 0\\n while U:\\n n_components += 1\\n [G, U] = DFS(G, U[0], U)\\n return n_components\",\n \"def number_of_connections(self, asn):\\n customer_count = 0\\n provider_count = 0\\n peer_count = 0\\n\\n for neighbor in nx.all_neighbors(self, asn):\\n edge_data = self.get_edge_data(asn, neighbor)\\n if edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as1\\\"] == asn:\\n customer_count += 1\\n elif edge_data[\\\"relationship\\\"] == -1 and edge_data[\\\"as2\\\"] == asn:\\n provider_count += 1\\n elif edge_data[\\\"relationship\\\"] == 0:\\n peer_count += 1\\n return customer_count, provider_count, peer_count\",\n \"def get_graph_attributes(net_G):\\r\\n # number of nodes\\r\\n num_of_nodes = net_G.number_of_nodes()\\r\\n # number of nodes\\r\\n num_of_edges = net_G.number_of_edges()\\r\\n # density of net\\r\\n net_density = nx.density(net_G)\\r\\n # maximum degree and average degree\\r\\n nodes_degree = nx.degree(net_G)\\r\\n maximum_degree = max(nodes_degree, key=itemgetter(1))[0]\\r\\n average_degree = sum([node[1] for node in nodes_degree])/num_of_nodes\\r\\n # global clustering coefficient: n - count numbers of paths of length two\\r\\n nodes_triangles = nx.triangles(net_G)\\r\\n num_of_triangles = sum(nodes_triangles.values())\\r\\n pairs_path_length = dict(nx.all_pairs_shortest_path_length(net_G))\\r\\n n = 0 \\r\\n for node in pairs_path_length.keys(): \\r\\n for item in pairs_path_length[node].values():\\r\\n if item == 2:\\r\\n n = n + 1\\r\\n global_clustering_coefficient = (num_of_triangles * 6) / n\\r\\n # size of giant component\\r\\n giant_component = max(nx.connected_component_subgraphs(net_G),key=len)\\r\\n # return number of edges in graph=graph size\\r\\n size_of_giant = nx.Graph.size(giant_component)\\r\\n # calculate the average path length of giant component\\r\\n average_shortest_path_length = nx.average_shortest_path_length(giant_component)\\r\\n # maximum centrality and average centrality\\r\\n nodes_centrality = nx.degree_centrality(net_G)\\r\\n maximum_of_centrality = max(nodes_centrality.values())\\r\\n average_of_centrality = sum(nodes_centrality.values())/num_of_nodes\\r\\n # maximum betweenness centrality\\r\\n nodes_betweenness_centrality = nx.betweenness_centrality(net_G)\\r\\n maximum_betweenness_centrality = max(nodes_betweenness_centrality.values())\\r\\n # maximum closeness centrality\\r\\n nodes_closeness_centrality = nx.closeness_centrality(net_G)\\r\\n maximum_closeness_centrality = max(nodes_closeness_centrality.values())\\r\\n average_closeness_centrality = sum(nodes_closeness_centrality.values())/num_of_nodes\\r\\n # summarize graph attributes\\r\\n graph_attributes = [[\\\"Number of nodes:\\\", num_of_nodes], \\\\\\r\\n [\\\"Number of edges:\\\", num_of_edges], \\\\\\r\\n [\\\"Global clustering coefficient:\\\", global_clustering_coefficient], \\\\\\r\\n [\\\"Maximum degree:\\\", maximum_degree], \\\\\\r\\n [\\\"Average degree:\\\", average_degree], \\\\\\r\\n [\\\"Size of giant component:\\\", size_of_giant], \\\\\\r\\n [\\\"Average path length:\\\", average_shortest_path_length],\\\\\\r\\n [\\\"Maximum centrality:\\\", maximum_of_centrality], \\\\\\r\\n [\\\"Average centrality:\\\", average_of_centrality],\\\\\\r\\n [\\\"Maximum betweenness centrality:\\\", maximum_betweenness_centrality],\\\\\\r\\n [\\\"Maximum closeness centrality:\\\", maximum_closeness_centrality], \\\\\\r\\n [\\\"Average closeness centrality:\\\", average_closeness_centrality], \\\\\\r\\n [\\\"Net density:\\\", net_density]]\\r\\n return graph_attributes\",\n \"def _MocaCtlGetNodeIDs(self):\\n mc = subprocess.Popen([MOCACTL, 'showtbl', '--nodestats'],\\n stdout=subprocess.PIPE)\\n out, _ = mc.communicate(None)\\n nodes = set()\\n for line in out.splitlines():\\n node = NODE_RE.search(line)\\n if node is not None:\\n nodes.add(int(node.group(1)))\\n node_list = list(nodes)\\n length = len(node_list)\\n if int(self.AssociatedDeviceCount) != length:\\n type(self).AssociatedDeviceCount.Set(self, length)\\n return node_list\",\n \"def get_indegrees(graph: Graph):\\n transpose = get_transpose_graph(graph)\\n return {node: len(target_nodes) for node, target_nodes in transpose.items()}\",\n \"def getNeuronCount(self):\\n\\t\\treturn self.loader.getNeuronCount()\",\n \"def count_nodes(self, term=None, labels: istr = None):\",\n \"def add_number_of_lemmas(self):\\n self.lemmas = 0\\n for t in self.thys:\\n with open(t, 'r') as f:\\n for l in f:\\n if l.startswith(\\\"lemma\\\") or l.startswith(\\\"corollary\\\") or \\\\\\n l.startswith(\\\"theorem\\\"):\\n self.lemmas += 1\",\n \"def extract_path_count(self, metapaths=None, start_nodes=None, end_nodes=None, verbose=False, n_jobs=1,\\n return_sparse=False, sparse_df=True):\\n\\n return self._extract_metapath_feaures(metapaths=metapaths, start_nodes=start_nodes, end_nodes=end_nodes,\\n verbose=verbose, n_jobs=n_jobs, return_sparse=return_sparse,\\n sparse_df=sparse_df, func=mt.count_paths, mats=self.adj_matrices,\\n message='Path Count')\",\n \"def path_length(G, path, weight=\\\"weight\\\"):\\n length = 0\\n u = path[0]\\n for v in path[1:]:\\n length += G[u][v][weight]\\n u = v\\n return length\",\n \"def obstacle_count(self):\\n self.wide_scan()\\n found_something = False\\n counter = 0\\n for distance in self.scan:\\n if distance and distance < 200 and not found_something:\\n found_something = True\\n counter += 1\\n print(\\\"Object # %d found, I think\\\" % counter)\\n if distance and distance > 200 and found_something:\\n found_something = False\\n print(\\\"\\\\n----I SEE %d OBJECTS----\\\\n\\\" % counter)\",\n \"def count_paths((min_i, min_j), (max_i, max_j)):\\n\\n def explore((i, j), path):\\n found = 0\\n for (x, y) in neighbors((min_i, min_j), (max_i, max_j), (i, j)):\\n if (x, y) == (max_i, max_j):\\n found += 1\\n debug(\\\"neighbor %r of node %r on path %r is a goal node: +1\\\" % ((x, y), (i, j), path))\\n elif (x, y) in path: \\n debug(\\\"neighbor %r of node %r already on path %r; ignoring...\\\" % ((x, y), (i, j), path))\\n continue\\n else:\\n debug(\\\"neighbor %r of node %r not already on path %r; exploring ...\\\" % ((x, y), (i, j), path))\\n found += explore((x, y), mkpath(path, (x, y)))\\n return found\\n return explore((0, 0), set([(0, 0)]))\",\n \"def go_count(self, S_hit, S_go=None):\\n c={}\\n if S_go is not None: S_go=set(S_go)\\n for x in S_hit:\\n Y=self.GENE_GO.get(x, [])\\n if S_go is not None: Y = set(Y).intersection(S_go)\\n for y in Y:\\n c[y]=c.get(y,0)+1\\n return c\",\n \"def get_n_chains(self): \\n res_id_cnt = 0\\n tot_n_res = len(self.res_ids)\\n n_chns = 0\\n for res_id in self.res_ids:\\n res_chn_i = res_id[2]\\n if res_id_cnt > 1:\\n if res_chn_i == self.res_ids[res_id_cnt-1][2]:\\n pass\\n else:\\n n_chns+=1\\n res_id_cnt+=1\\n return n_chns\",\n \"def n(self):\\n return sum(list(self.nodes.values()))\",\n \"def count(self):\\n return self.__tree.node_count\",\n \"def in_degree_distribution (digraph) :\\n\\n in_degree_dist = dict ()\\n in_degrees = compute_in_degrees (digraph)\\n\\n for node in in_degrees :\\n if in_degrees[node] in in_degree_dist :\\n in_degree_dist[in_degrees[node]] += 1\\n else :\\n in_degree_dist[in_degrees[node]] = 1\\n\\n return in_degree_dist\",\n \"def joincount(pntGraph, lineGraph, criterion='', threshold=0):\\n matNumDict, _ = spatialjoin._spatialjoin(pntGraph, lineGraph, criterion, threshold)\\n for edge in lineGraph.edges(data=True):\\n edge[2]['joinCount'] = matNumDict[edge[2]['Ind']]\\n print('The join count is added to the POLYLINE type graph.')\",\n \"def nb_simple_paths(self, start, end):\\n if start not in self.nodes or end not in self.nodes:\\n return None\\n\\n visited = set()\\n nb_paths = 0\\n\\n def search(node, goal):\\n nonlocal nb_paths\\n visited.add(node)\\n\\n if node == goal:\\n nb_paths += 1\\n else:\\n for neighbor in self.nodes[node]:\\n if neighbor not in visited:\\n search(neighbor, goal)\\n\\n visited.remove(node)\\n\\n search(start, end)\\n return nb_paths\",\n \"def number_tokens(dgraph):\\n cnt = 0\\n for node in dgraph.subgraphs(exclude_root=True):\\n node[WORD] = (cnt, node[WORD])\\n cnt += 1\\n return dgraph\",\n \"def count_common_connections(network, user_A, user_B):\\n count = 0\\n if user_A not in network or user_B not in network:\\n return False\\n for person in network[user_A][0]:\\n if person in network[user_B][0]:\\n count += 1\\n return count\",\n \"def get_marble_count(self):\",\n \"def sumoflemmas():\\n\\n wordnet_length= 74374\\n\\n wordnet_occurrences = 94949 #not unique words\\n \\\"\\\"\\\"stepdown = wn.synsets('entity')[0]\\n synsets = downtree.downtree(stepdown, [])\\n synsets.append(stepdown)\\n synsets = set(synsets)\\n #wordnet_length = len(set(synsets))\\n\\n nameset =[]\\n #fdist = FreqDist(brown.words())\\n for syn in synsets:\\n for lem in syn.lemmas():\\n nameset.append(lem.count())\\n #nameset.append(lem.name())\\n\\n # for wh in set(nameset):\\n # wordnet_occurrences.append(fdist[wh])\\n\\n # Should give set of numbers, with which to sum\\n\\n # wordnet_occurrences = sum(wordnet_occurences)\\n\\n # Not sure why this returns 105000, seems like a reasonable number,\\n # For example, 'dog' returns 70 instead of 42. Perhaps it uses a different\\n # percentage of the wordnet corpus. Or was counted wrong. Or this one was,\\n # Either way, my understanding is that since we are doing a probability with it,\\n # the actual number shouldn't matter too much at these ranges, as long as both the\\n # numerator and the denominator are done using the same method.\\n\\n\\n wordnet_occurrences = sum(nameset)\\\"\\\"\\\"\\n\\n return wordnet_occurrences\",\n \"def countRecursiveReferences(self) -> Tuple[Dict[str, List[str]], Dict[str, Dict[str, int]]]:\\n countReferences = {}\\n isReferencedBy = {}\\n for nt in self.non_terminals: # for each non-terminal in the grammar\\n for production in self.grammar[nt]: # for each possible production on that non terminal\\n count = {}\\n for option in production.split(): # iterate over the production's terms\\n count.setdefault(option, 0)\\n if option in self.non_terminals: # if the term is a non terminal\\n count[option] += 1 # the number of times that option has been referenced increases\\n isReferencedBy.setdefault(option, set())\\n isReferencedBy[option].add(nt)\\n \\n for key in count:\\n count.setdefault(key, 0)\\n countReferences.setdefault(key, {})\\n countReferences[key].setdefault(nt, 0)\\n\\n countReferences[key][nt] = max(\\n countReferences[key][nt], count[key]) # the number of references of the non terminal is for this\\n # term is the maximum between all productions in this non terminal\\n\\n return isReferencedBy, countReferences\",\n \"def count(self):\\r\\n return self.count_helper(self.top_node)\",\n \"def get_mention_counts(articles, skip_nils=True):\\n gold_forms=[]\\n gold_links=[]\\n for example_article in articles:\\n for entity in example_article.entity_mentions:\\n mention=entity.mention\\n meaning=entity.gold_link\\n if not skip_nils or meaning!='--NME--':\\n gold_forms.append(mention)\\n gold_links.append(meaning)\\n cnt_instances=Counter(gold_links)\\n cnt_forms=Counter(gold_forms)\\n return cnt_instances, cnt_forms\",\n \"def count(self):\\n count = {}\\n\\n for path, lines in self.lines_added.items():\\n count[path] = count.get(path, 0) + sum(lines)\\n\\n for path, lines in self.lines_removed.items():\\n count[path] = count.get(path, 0) + sum(lines)\\n\\n return count\",\n \"def num_nodes(g):\\n return len(g.keys())\",\n \"def get_stats(sents, **dummy_args):\\n from collections import Counter\\n statsmode_results = Counter() \\n # first, put the relevant trees into temp file\\n\\n for sent in sents:\\n statsmode_results['Sentences'] += 1\\n deps = get_deps(sent, dep_type)\\n numpass = len([x for x in deps.links if x.type.endswith('pass')])\\n statsmode_results['Passives'] += numpass\\n statsmode_results['Tokens'] += len(sent.tokens)\\n words = [w.word for w in sent.tokens if w.word is not None and w.word.isalnum()]\\n statsmode_results['Words'] += len(words)\\n statsmode_results['Characters'] += len(''.join(words))\\n\\n to_open = '\\\\n'.join(s.parse_string.strip() for s in sents)\\n\\n from corpkit.dictionaries.process_types import processes\\n from corpkit.other import as_regex\\n tregex_qs = {'Imperative': r'ROOT < (/(S|SBAR)/ < (VP !< VBD !< VBG !$ NP !$ SBAR < NP !$-- S !$-- VP !$ VP)) !<< (/\\\\?/ !< __) !<<- /-R.B-/ !<<, /(?i)^(-l.b-|hi|hey|hello|oh|wow|thank|thankyou|thanks|welcome)$/',\\n 'Open interrogative': r'ROOT < SBARQ <<- (/\\\\?/ !< __)', \\n 'Closed interrogative': r'ROOT ( < (SQ < (NP $+ VP)) << (/\\\\?/ !< __) | < (/(S|SBAR)/ < (VP $+ NP)) <<- (/\\\\?/ !< __))',\\n 'Unmodalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP !< MD)))',\\n 'Modalised declarative': r'ROOT < (S < (/(NP|SBAR|VP)/ $+ (VP < MD)))',\\n 'Open class': r'/^(NN|JJ|VB|RB)/ < __',\\n 'Closed class': r'__ !< __ !> /^(NN|JJ|VB|RB)/',\\n 'Clauses': r'/^S/ < __',\\n 'Interrogative': r'ROOT << (/\\\\?/ !< __)',\\n 'Mental processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\\\\n as_regex(processes.mental, boundaries='w'),\\n 'Verbal processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\\\\n as_regex(processes.verbal, boundaries='w'),\\n 'Relational processes': r'VP > /^(S|ROOT)/ <+(VP) (VP <<# /%s/)' % \\\\\\n as_regex(processes.relational, boundaries='w'),\\n 'Verbless clause': r'/^S/ !<< /^VB.?/'}\\n\\n for name, q in sorted(tregex_qs.items()):\\n res = tregex_engine(query=q, \\n options=['-o', '-C'], \\n corpus=to_open, \\n root=root\\n )\\n statsmode_results[name] += int(res)\\n if root:\\n root.update()\\n return statsmode_results, []\",\n \"def count_other_citations(pmid,linkname):\\n link = f\\\"https://www.ncbi.nlm.nih.gov/pubmed?linkname={linkname}&from_uid={pmid}\\\"\\n sleep(0.3)\\n page = requests.get(link).text\\n soup = BeautifulSoup(page, 'html.parser') \\n count = int(soup.find_all(attrs={\\\"name\\\": \\\"ncbi_resultcount\\\"})[0][\\\"content\\\"])\\n return(count)\",\n \"def connected_component_statistics(self, printStats=False):\\n lengths = self.connected_component_lengths()\\n lengthDict = dict(collections.Counter(lengths))\\n\\n if printStats:\\n orderedLengthDict = collections.OrderedDict(sorted(lengthDict.items()))\\n numberOfGroups = nx.number_connected_components(self.return_undirected())\\n for k, v in orderedLengthDict.iteritems():\\n percent = round((100.00*v / numberOfGroups), 2)\\n print str(k) + ' nodes: ' + str(v) + ' (' + str(percent) + '%) groups'\\n print '-----------------------------------------'\\n print 'TOTAL: ' + str(super(SynonymNetwork, self).number_of_nodes()) + ' nodes in network, ' + str(numberOfGroups) + ' distinct groups'\\n else:\\n return lengthDict\",\n \"def degree( self, n ):\\n return len(self._G.neighbors(n))\",\n \"def findDiscripancies(taxonomy):\\n i = 0\\n for entry in taxonomy:\\n if entry['parentName'] != None:\\n print entry['nodeName']\\n if entry['nodeName'].lower() == entry['parentName'].lower():\\n i += 1\\n print \\\"No of same nodes = {} \\\" .format(i)\",\n \"def extract_number_target_genes(d, g, miranda_fnm):\\n\\toutput_nm = \\\"%s_counts.txt\\\"%(miranda_fnm[:-4])\\n\\toutput = open(output_nm, 'w')\\n\\toutput.write(\\\"miRNA\\\\ttotal_target_genes\\\\ttarget_genes_down\\\\ttarget_genes\\\\n\\\")\\n\\tfor key in d:\\n\\t\\tif len(d[key]) > 0:\\n\\t\\t\\t#print key, len(d[key])\\n\\t\\t\\toutput.write(\\\"%s\\\\t%s\\\\t%s\\\\t%s\\\\n\\\"%(key, len(d[key]), \\n\\t\\t\\t\\tlen(g[key]), str(g[key]).strip('[]')))\\n\\n\\toutput.close()\",\n \"def count_unvisited(data):\\n count = sum(n.count(\\\"n\\\") for n in data)\\n return count\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6493108","0.6265583","0.61763126","0.58439344","0.58234376","0.5724303","0.5712313","0.56395566","0.5600497","0.5599743","0.5586163","0.55701447","0.5519347","0.55081844","0.54878646","0.54671645","0.54594654","0.54498696","0.5437356","0.543203","0.5405759","0.5396653","0.5395347","0.53907776","0.53864044","0.53670144","0.53615487","0.535674","0.53499484","0.53321254","0.53251624","0.53243065","0.53128326","0.5298376","0.52956533","0.5287846","0.52740324","0.5259051","0.52541834","0.5248716","0.5243441","0.5241756","0.5238268","0.52300626","0.5221751","0.52167386","0.52103144","0.5208366","0.52068716","0.5204859","0.5200694","0.5197041","0.51924837","0.5189736","0.5181274","0.51737785","0.5168069","0.5168069","0.51522475","0.51491016","0.5145121","0.5143054","0.5137679","0.51350886","0.51288456","0.51259404","0.5125686","0.5123379","0.51124877","0.5111054","0.51105446","0.51103276","0.5110214","0.51091355","0.5105264","0.51032645","0.5082413","0.50823385","0.50790775","0.50762004","0.50639254","0.5061002","0.5057997","0.5051042","0.5042659","0.5041378","0.50365263","0.5034905","0.50344276","0.50283617","0.5014701","0.5014594","0.5012631","0.50116533","0.50110537","0.50108844","0.50103956","0.50061834","0.50060505","0.50036085"],"string":"[\n \"0.6493108\",\n \"0.6265583\",\n \"0.61763126\",\n \"0.58439344\",\n \"0.58234376\",\n \"0.5724303\",\n \"0.5712313\",\n \"0.56395566\",\n \"0.5600497\",\n \"0.5599743\",\n \"0.5586163\",\n \"0.55701447\",\n \"0.5519347\",\n \"0.55081844\",\n \"0.54878646\",\n \"0.54671645\",\n \"0.54594654\",\n \"0.54498696\",\n \"0.5437356\",\n \"0.543203\",\n \"0.5405759\",\n \"0.5396653\",\n \"0.5395347\",\n \"0.53907776\",\n \"0.53864044\",\n \"0.53670144\",\n \"0.53615487\",\n \"0.535674\",\n \"0.53499484\",\n \"0.53321254\",\n \"0.53251624\",\n \"0.53243065\",\n \"0.53128326\",\n \"0.5298376\",\n \"0.52956533\",\n \"0.5287846\",\n \"0.52740324\",\n \"0.5259051\",\n \"0.52541834\",\n \"0.5248716\",\n \"0.5243441\",\n \"0.5241756\",\n \"0.5238268\",\n \"0.52300626\",\n \"0.5221751\",\n \"0.52167386\",\n \"0.52103144\",\n \"0.5208366\",\n \"0.52068716\",\n \"0.5204859\",\n \"0.5200694\",\n \"0.5197041\",\n \"0.51924837\",\n \"0.5189736\",\n \"0.5181274\",\n \"0.51737785\",\n \"0.5168069\",\n \"0.5168069\",\n \"0.51522475\",\n \"0.51491016\",\n \"0.5145121\",\n \"0.5143054\",\n \"0.5137679\",\n \"0.51350886\",\n \"0.51288456\",\n \"0.51259404\",\n \"0.5125686\",\n \"0.5123379\",\n \"0.51124877\",\n \"0.5111054\",\n \"0.51105446\",\n \"0.51103276\",\n \"0.5110214\",\n \"0.51091355\",\n \"0.5105264\",\n \"0.51032645\",\n \"0.5082413\",\n \"0.50823385\",\n \"0.50790775\",\n \"0.50762004\",\n \"0.50639254\",\n \"0.5061002\",\n \"0.5057997\",\n \"0.5051042\",\n \"0.5042659\",\n \"0.5041378\",\n \"0.50365263\",\n \"0.5034905\",\n \"0.50344276\",\n \"0.50283617\",\n \"0.5014701\",\n \"0.5014594\",\n \"0.5012631\",\n \"0.50116533\",\n \"0.50110537\",\n \"0.50108844\",\n \"0.50103956\",\n \"0.50061834\",\n \"0.50060505\",\n \"0.50036085\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7180617"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20177,"cells":{"query":{"kind":"string","value":"Create a new point at the origin"},"document":{"kind":"string","value":"def __init__(self):\n self.x = 0\n self.y = 0"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def clone(self):\n return Point(self.x, self.y)","def clone(self):\n return Point(self.x, self.y)","def makePoint( nX, nY ):\n oPoint = createUnoStruct( \"com.sun.star.awt.Point\" )\n oPoint.X = nX\n oPoint.Y = nY\n return oPoint","def makePoint( nX, nY ):\n oPoint = createUnoStruct( \"com.sun.star.awt.Point\" )\n oPoint.X = nX\n oPoint.Y = nY\n return oPoint","def set_new_location(self, xPos, yPos):","def getPoint(self):\n return Point(*self.position)","def create_position(self):\n raise NotImplementedError","def generate_point(self):\n x = random.uniform(0.0, 9999.9)\n y = random.uniform(0.0, 9999.9)\n random_point = Point(x, y)\n assert isinstance(random_point, Point)\n return random_point","def _set_origin(self):\n self += helper.circle(cx=self.__dict__['x'], cy=self.__dict__['y'], r=2, fill=\"black\", stroke=\"black\", style=\"fill-opacity: 50%\")\n self += helper.text(\"(0,0)\", x=self.__dict__['x']+5, y=self.__dict__['y']-5, style=\"fill-opacity: 50%\")","def move_origin(self, x, y):\n return Position(self.x - x, self.y - y)","def center_on_origin(self, new_origin=(0, 0)):\n center = self.center()\n\n # translate x and y\n x_new = self.x - center[0] + new_origin[0]\n y_new = self.y - center[1] + new_origin[1]\n\n return Route(x_new, y_new, z=self.z)","def recenter(self, point=(0, 0)):\n self.center = Point(*point)","def __new_position(self):\n iterables = [range(self.size_x), range(self.size_y)]\n points = [] # Save all points in size.\n for point in itertools.product(*iterables):\n points.append(point)\n\n current_points = [] # Save used points.\n for object in self.objects:\n if (object.x, object.y) not in current_points:\n current_points.append((object.x, object.y))\n\n for point in current_points:\n points.remove(point) # Remove all used points.\n\n location = np.random.choice(a=range(len(points)), replace=False)\n return points[location]","def from_origin(self):\n return type(self)(\n radius=self.radius, origin=Point(0, 0), size=self.size, sample_insets=self.sample_insets,\n altoffset=self.altoffset\n )","def point(self):\n return Point(self._x, self._y)","def setPoint(self, point):\n self._point = point\n self._point = self.projectPoint(Point.origin(point.dimension))","def pos_as_point(self) -> Point:\n return Point(self.x, self.y, 0)","def _make_point(self, active_point):\n # --------------------------------\n # Create Random Parameters\n # --------------------------------\n for _ in range(self._k):\n # Defines radial distance from active_point.\n rho = np.random.uniform(self._radius, 2 * self._radius)\n # Defines angle from active_point. Requires multiple angles for higher dimensional planes.\n theta = [np.random.uniform(0, 2 * np.pi) for _ in range(self._dim - 1)]\n\n # --------------------------------\n # Create New Point\n # --------------------------------\n\n # Create a 2D point using first theta angle.\n new_point = [active_point[0] + rho * np.cos(theta[0]), active_point[1] + rho * np.sin(theta[0])]\n # Generate more components of the coordinate for higher dimensional planes.\n new_point.extend([active_point[i] + rho * np.sin(theta[i-1]) for i in range(2, active_point.shape[0])])\n new_point = np.array(new_point)\n\n # Confirm point is valid\n if self._valid_point(new_point):\n return new_point\n return None","def set_point(self, x, y):\n self._x = x\n self._y = y","def set_origin( self, x, y ):\n\t\tself.x_offset = x\n\t\tself.y_offset = y\n\t\tself.width = (self._raw_width-x)\n\t\tself.height = (self._raw_height-y)","def create_new_point(self, coords, **options):\n\n if 'fill' not in options:\n options['fill'] = self.variables.foreground_color\n\n x1, y1 = (coords[0] - self.variables.point_size), (coords[1] - self.variables.point_size)\n x2, y2 = (coords[0] + self.variables.point_size), (coords[1] + self.variables.point_size)\n shape_id = self.create_oval(x1, y1, x2, y2, **options)\n self.variables.vector_objects[str(shape_id)] = VectorObject(SHAPE_TYPES.POINT, options)\n self.variables.vector_objects[str(shape_id)].point_size = self.variables.point_size\n self.variables.shape_ids.append(shape_id)\n self.set_shape_pixel_coords_from_canvas_coords(shape_id, coords)\n self.variables.current_shape_id = shape_id\n return shape_id","def new_position(self, p):\n if self.track:\n self.gnx = p.gnx\n else:\n p = self.get_position()\n\n self.new_position_edit(p)\n self.new_position_view(p)","def getNewCoordinate(self):\n R = GeometryToolBox.rotation_matrix_from_vectors([1, 0, 0], self.nVec)\n x = self.nVec\n y = np.dot(R, np.array([0, 1, 0]))\n z = np.dot(R, np.array([0, 0, 1]))\n self.XYZCoordinate = np.vstack((x, y, z))\n return self.XYZCoordinate","def setPoint(self, point):\n self.position = point.position","def createFromPoint(cls, point, **kwargs):\n return cls(point.x, point.y, **kwargs)","def create_point(xa,ya,col):\n disque = canvas.create_oval(xa-(rayon),ya-(rayon),xa+(rayon),ya+(rayon),fill=\"white\",outline=col)\n return disque","def position(self, t):\n return vector_add(self.origin, self.direction.scale(t))","def move(self, point: Point) -> \"Location\":\n\n return Location(point=self.point + point, labware=self._given_labware)","def create_random_point(x0,y0,distance): \n r = distance/ 111300\n u = np.random.uniform(0,1)\n v = np.random.uniform(0,1)\n w = r * np.sqrt(u)\n t = 2 * np.pi * v\n x = w * np.cos(t)\n x1 = x / np.cos(y0)\n y = w * np.sin(t)\n return (x0+x1, y0 +y)","def point(cls): # No range because it's unknown at this time.\r\n def factory(i, name):\r\n return cls(i, name, (0, 0), lambda a: point.Point(*a).floor(), None)\r\n return factory","def add_point(self, x: int, y: int):\n self.state[x, y] = 1","def add_point(self, x: int, y: int):\n self.state[x, y] = 1","def add_point(self, x: int, y: int):\n self.state[x, y] = 1","def setPose(self, newPosition):\n self.origin1 = newPosition\n self.axis1 = self.G_gl[0:3, 0:3] @ self.axis0","def origin():\n\n # indices: [axis, point]\n return numpy.zeros((3, 1))","def create(self, pos):\n self.pos = pos","def __init__(self, point=None):\n\t\tif point is None:\n\t\t\tpoint = (0,0)\n\t\tself.x = point[0]\n\t\tself.y = point[1]","def __init__(self, x=0, y=0):\n self.x = x\n self.y = y\n super(Point, self).__init__()","def __init__(self, x, y):\n self.x = x\n self.y = y\n self.x1 = self.x + 30 # largeur et hauteur fixees\n self.y1 = self.y + 30","def get_origin(self):\n return self.coord_cls(x=0, y=0, z=0, system=self)","def initialCoordinates():\r\n return (-250,-250)","def set_drone_position(self, new_point):\n self.drone.set_drone_position(new_point)","def get_origin(self):\n return self.coord_cls(x=0, y=0, system=self)","def get_new_origin(self, direction=None):\n y, x = 1, 0\n direction_coords = {'origin': (0, 0), 'right': (0, 1), 'left': (0, -1)}\n if direction and direction in direction_coords:\n y, x = direction_coords[direction]\n return (self.origin[0] + y, self.origin[1] + x)","def move_to_origin(x):\n # Correct x so it is centered at (0,0)\n tx = np.mean(x[:no_points, :])\n ty = np.mean(x[no_points:, :])\n x[:no_points, :] = (x[:no_points, :] - tx)\n x[no_points:, :] = (x[no_points:, :] - ty)\n return x, tx, ty","def setStartPoint(self, x, y):\n self._origin = QPointF(x, y)","def position(self, x, y):\n self.x = x \n self.y = y\n self.pos[0] = x \n self.pos[1] = y","def new_point(\n self, data: Union[Tensor, np.ndarray, Sequence[Sequence[float]]]\n ) -> 'BasePoints':\n new_tensor = self.tensor.new_tensor(data) \\\n if not isinstance(data, Tensor) else data.to(self.device)\n original_type = type(self)\n return original_type(\n new_tensor,\n points_dim=self.points_dim,\n attribute_dims=self.attribute_dims)","def add_on_land_position(self) -> Point2:\n return self.position.offset(Point2((-2.5, 0.5)))","def clone(self):\n return _libsbml.Point_clone(self)","def point_at(self, abscissa):\n return self.zero + abscissa * self.direction","def displace(self, (y_offset, x_offset)):\n ret = copy(self)\n ret.y += y_offset\n ret.x += x_offset\n return ret","def __abs__(self) -> PointType:\n return Point(abs(self.x), abs(self.y))","def _transform_point(self, x, y):\n return (x, y)","def reflect_x(self):\n r_x = self.x\n r_y = self.y *-1\n\n return (Point(r_x,r_y))","def newf(self,*args,**kargs): \n return self._set_coords(coords_func(self.coords,*args,**kargs))","def set_origin(self, origin_x, origin_y):\r\n self.x = origin_x - (self.rect.width / 2)\r\n self.y = origin_y + self.rect.height\r\n self._update_rect()","def move_origin(self, x, y):\n return RobotPosition(self.x - x, self.y - y, self.theta)","def point_at(self, u, v, world=True):\n u = u * pi\n v = v * PI2\n x = self.radius * cos(u) * sin(v)\n y = self.radius * sin(u) * sin(v)\n z = self.radius * cos(v)\n point = Point(x, y, z)\n if world:\n point.transform(self.transformation)\n return point","def translate_to_point_O(self):\n self.translate(-self.pcs.origin)","def copy(self):\n return Point(self.data, name=self.name+\"'\")","def set_position(self, x, y):\n self.geometry('%s%s' % (x, y))","def to_point(self) -> Point:\r\n return Point(self.tile_x * TILE_SIZE, self.tile_y * TILE_SIZE)","def create_point(x_crd, y_crd):\n\n Point = namedtuple(\"Point\", \"x_crd y_crd\")\n return Point(x_crd, y_crd)","def _add_point(self):\r\n self.command_stack.do(model.structure.AddPoint(self._structure, self._point_index+1, 0, 0))","def reflect_x(self):\n\n return Point(self.x, - self.y)","def point(self) -> Point:\n return Point.from_np_array(self.position)","def teleport(self, x, y):\n self.rect.x = x\n self.rect.y = y","def lift(point):\n return gs.copy(point)","def __add__(self, p):\n return Point(self.x + p.x, self.y + p.y)","def spawn(self, y, x, h, w):\n self.pos = (np.random.randint(y, y + h), np.random.randint(x, x + w))","def getNewPosition(self, angle, speed):\n old_x, old_y = self.getX(), self.getY()\n # Compute the change in position\n delta_y = speed * math.cos(math.radians(angle))\n delta_x = speed * math.sin(math.radians(angle))\n # Add that to the existing position\n new_x = old_x + delta_x\n new_y = old_y + delta_y\n #print \"new x = \" + str(new_x) + \" new y \" + str(new_y)\n #print \"floor of x = \" + str(math.floor(new_x)) + \" floor of y = \" + str(math.floor(new_y))\n \n return Position(new_x, new_y)","def point_add(self, a, b):\n\n if a.at_inf and b.at_inf: return point.inf()\n if a.at_inf: return b.dup()\n if b.at_inf: return a.dup()\n if a == b: return self.point_double(a)\n if a.x == b.x and a.y == -b.y: return point.inf()\n\n x1, y1, x2, y2 = modp(self.p, a.x, a.y, b.x, b.y)\n L = (y2 - y1) / (x2 - x1)\n x3 = L ** 2 - x1 - x2\n y3 = L * (x1 - x3) - y1\n return point.xy(int(x3), int(y3))","def set_position(self, x, y):\n self.tx = -x\n self.ty = -y","def _moveTo(self, pt):\n self._handleAnchor()\n t = \"M%s\" % (pointToString(pt))\n self._commands.append(t)\n self._lastCommand = \"M\"\n self._lastX, self._lastY = pt","def setPoint(self, point):\n self.point = point","def __init__(self, origin = Vector(0,0,0), color=Colors.White) -> None:\n self.origin = origin\n self.color = color","def test_shift_point(self):\n point = (0,0)\n new_point = utils.shift_point(point, 3, 4)\n self.assertEqual((3,4), new_point)\n\n point = (-2.34, 1.19)\n new_point = utils.shift_point(point, 2.34, -1.19)\n self.assertEqual((0,0), new_point)","def add(self, point):\n if not isinstance(point, Point):\n raise ValueError('Argument point should be an Point instance')\n self.x = self.x + point.x\n self.y = self.y + point.y","def point(cls, x, y, crs=None):\n crs = _validate_crs(crs)\n return cls(arctern.ST_Point(x, y), crs=crs)","def place(self,y,x):\n self.y = y\n self.x = x","def fromPoint(cls, p: Point):\n return cls(p.coords)","def shift_point(mutated_genome,index):\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\n point = mutated_genome[index][2][point_index]\n newpoint = (point[0]+Xval,point[1]+Yval)\n mutated_genome[index][2][point_index] = newpoint","def point(self, value: Point):\n self._point = value","def new(self, point,ment_id=None):\n mat = np.zeros((1, np.size(point)))\n mat[0] = point\n return CompleteVec(mat, None,self.max_num_samples)","def translate_to_origin(shape):\n s = shape\n center_x, center_y = Shape.get_centroid(s)\n for pt in s.pts:\n pt.x -= center_x\n pt.y -= center_y\n return s","def setzePosition(self, x, y):\n self.zielX = x\n self.zielY = y","def set_reference_point(self):\n theta = 2*math.pi-math.radians(self.REFERENCE_ANGLE)\n origin_pos = self.locations[0].get_position()\n target_pos = self.locations[1].get_position()\n v = self.calculate_displacement(origin_pos, target_pos, transpose=True)\n v_norm = math.sqrt(v[0]**2+v[1]**2)\n rotation_matrix = np.matrix([[math.cos(theta), -math.sin(theta)],\n [math.sin(theta), math.cos(theta)]])\n offset_x, offset_y = origin_pos\n reference_point_matrix = np.array([offset_x, offset_y])+np.transpose((1/v_norm)*rotation_matrix*v)\n self.reference_point = reference_point_matrix.tolist()[0]","def location(self, value: 'Point'):\n self.geometry.location = value","def _as_parameter_(self):\n return POINT(self.x, self.y)","def reverse(self):\n x = self._x * -1\n y = self._y * -1\n return Point(x,y)","def moveTo(self, pt: Tuple[float, float]) -> None:\n raise NotImplementedError","def __init__(self, pt1, pt2):\n self.set_points(pt1, pt2)","def _adjust_point_to_upperleft(self, layername, point_object):\n layer_config = self.layers_config[layername]\n point_position = layer_config[\"point_position\"]\n pixel_size = layer_config[\"pixel_size\"]\n x, y = point_object\n if point_position == \"upperright\":\n x -= pixel_size\n elif point_position == \"lowerright\":\n x -= pixel_size\n y -= pixel_size\n elif point_position == \"lowerleft\":\n y -= pixel_size\n elif point_position == \"center\":\n x -= point_position/2.0\n y -= pixel_size/2.0\n\n return Point(x, y, srid=point_object.srid)","def transformToOrigin(self):\n return Transform.shiftOrigin(self.point, self.head)","def modifyPoint(self, *args, **kwargs):\n ...","def position(self):\n return pm.datatypes.Point(self.transform.getTranslation(ws=True))","def set_initial_point(self, point):\r\n return self._studio.set_initial_point(point)","def position(self, create, position=2, **kwargs): # pylint: disable=unused-argument, method-hidden\r\n self.position = position","def position(self, create, position=2, **kwargs): # pylint: disable=unused-argument, method-hidden\r\n self.position = position","def add(self, other):\n x = self._x + other.get_x()\n y = self._y + other.get_y()\n return Point(x,y)"],"string":"[\n \"def clone(self):\\n return Point(self.x, self.y)\",\n \"def clone(self):\\n return Point(self.x, self.y)\",\n \"def makePoint( nX, nY ):\\n oPoint = createUnoStruct( \\\"com.sun.star.awt.Point\\\" )\\n oPoint.X = nX\\n oPoint.Y = nY\\n return oPoint\",\n \"def makePoint( nX, nY ):\\n oPoint = createUnoStruct( \\\"com.sun.star.awt.Point\\\" )\\n oPoint.X = nX\\n oPoint.Y = nY\\n return oPoint\",\n \"def set_new_location(self, xPos, yPos):\",\n \"def getPoint(self):\\n return Point(*self.position)\",\n \"def create_position(self):\\n raise NotImplementedError\",\n \"def generate_point(self):\\n x = random.uniform(0.0, 9999.9)\\n y = random.uniform(0.0, 9999.9)\\n random_point = Point(x, y)\\n assert isinstance(random_point, Point)\\n return random_point\",\n \"def _set_origin(self):\\n self += helper.circle(cx=self.__dict__['x'], cy=self.__dict__['y'], r=2, fill=\\\"black\\\", stroke=\\\"black\\\", style=\\\"fill-opacity: 50%\\\")\\n self += helper.text(\\\"(0,0)\\\", x=self.__dict__['x']+5, y=self.__dict__['y']-5, style=\\\"fill-opacity: 50%\\\")\",\n \"def move_origin(self, x, y):\\n return Position(self.x - x, self.y - y)\",\n \"def center_on_origin(self, new_origin=(0, 0)):\\n center = self.center()\\n\\n # translate x and y\\n x_new = self.x - center[0] + new_origin[0]\\n y_new = self.y - center[1] + new_origin[1]\\n\\n return Route(x_new, y_new, z=self.z)\",\n \"def recenter(self, point=(0, 0)):\\n self.center = Point(*point)\",\n \"def __new_position(self):\\n iterables = [range(self.size_x), range(self.size_y)]\\n points = [] # Save all points in size.\\n for point in itertools.product(*iterables):\\n points.append(point)\\n\\n current_points = [] # Save used points.\\n for object in self.objects:\\n if (object.x, object.y) not in current_points:\\n current_points.append((object.x, object.y))\\n\\n for point in current_points:\\n points.remove(point) # Remove all used points.\\n\\n location = np.random.choice(a=range(len(points)), replace=False)\\n return points[location]\",\n \"def from_origin(self):\\n return type(self)(\\n radius=self.radius, origin=Point(0, 0), size=self.size, sample_insets=self.sample_insets,\\n altoffset=self.altoffset\\n )\",\n \"def point(self):\\n return Point(self._x, self._y)\",\n \"def setPoint(self, point):\\n self._point = point\\n self._point = self.projectPoint(Point.origin(point.dimension))\",\n \"def pos_as_point(self) -> Point:\\n return Point(self.x, self.y, 0)\",\n \"def _make_point(self, active_point):\\n # --------------------------------\\n # Create Random Parameters\\n # --------------------------------\\n for _ in range(self._k):\\n # Defines radial distance from active_point.\\n rho = np.random.uniform(self._radius, 2 * self._radius)\\n # Defines angle from active_point. Requires multiple angles for higher dimensional planes.\\n theta = [np.random.uniform(0, 2 * np.pi) for _ in range(self._dim - 1)]\\n\\n # --------------------------------\\n # Create New Point\\n # --------------------------------\\n\\n # Create a 2D point using first theta angle.\\n new_point = [active_point[0] + rho * np.cos(theta[0]), active_point[1] + rho * np.sin(theta[0])]\\n # Generate more components of the coordinate for higher dimensional planes.\\n new_point.extend([active_point[i] + rho * np.sin(theta[i-1]) for i in range(2, active_point.shape[0])])\\n new_point = np.array(new_point)\\n\\n # Confirm point is valid\\n if self._valid_point(new_point):\\n return new_point\\n return None\",\n \"def set_point(self, x, y):\\n self._x = x\\n self._y = y\",\n \"def set_origin( self, x, y ):\\n\\t\\tself.x_offset = x\\n\\t\\tself.y_offset = y\\n\\t\\tself.width = (self._raw_width-x)\\n\\t\\tself.height = (self._raw_height-y)\",\n \"def create_new_point(self, coords, **options):\\n\\n if 'fill' not in options:\\n options['fill'] = self.variables.foreground_color\\n\\n x1, y1 = (coords[0] - self.variables.point_size), (coords[1] - self.variables.point_size)\\n x2, y2 = (coords[0] + self.variables.point_size), (coords[1] + self.variables.point_size)\\n shape_id = self.create_oval(x1, y1, x2, y2, **options)\\n self.variables.vector_objects[str(shape_id)] = VectorObject(SHAPE_TYPES.POINT, options)\\n self.variables.vector_objects[str(shape_id)].point_size = self.variables.point_size\\n self.variables.shape_ids.append(shape_id)\\n self.set_shape_pixel_coords_from_canvas_coords(shape_id, coords)\\n self.variables.current_shape_id = shape_id\\n return shape_id\",\n \"def new_position(self, p):\\n if self.track:\\n self.gnx = p.gnx\\n else:\\n p = self.get_position()\\n\\n self.new_position_edit(p)\\n self.new_position_view(p)\",\n \"def getNewCoordinate(self):\\n R = GeometryToolBox.rotation_matrix_from_vectors([1, 0, 0], self.nVec)\\n x = self.nVec\\n y = np.dot(R, np.array([0, 1, 0]))\\n z = np.dot(R, np.array([0, 0, 1]))\\n self.XYZCoordinate = np.vstack((x, y, z))\\n return self.XYZCoordinate\",\n \"def setPoint(self, point):\\n self.position = point.position\",\n \"def createFromPoint(cls, point, **kwargs):\\n return cls(point.x, point.y, **kwargs)\",\n \"def create_point(xa,ya,col):\\n disque = canvas.create_oval(xa-(rayon),ya-(rayon),xa+(rayon),ya+(rayon),fill=\\\"white\\\",outline=col)\\n return disque\",\n \"def position(self, t):\\n return vector_add(self.origin, self.direction.scale(t))\",\n \"def move(self, point: Point) -> \\\"Location\\\":\\n\\n return Location(point=self.point + point, labware=self._given_labware)\",\n \"def create_random_point(x0,y0,distance): \\n r = distance/ 111300\\n u = np.random.uniform(0,1)\\n v = np.random.uniform(0,1)\\n w = r * np.sqrt(u)\\n t = 2 * np.pi * v\\n x = w * np.cos(t)\\n x1 = x / np.cos(y0)\\n y = w * np.sin(t)\\n return (x0+x1, y0 +y)\",\n \"def point(cls): # No range because it's unknown at this time.\\r\\n def factory(i, name):\\r\\n return cls(i, name, (0, 0), lambda a: point.Point(*a).floor(), None)\\r\\n return factory\",\n \"def add_point(self, x: int, y: int):\\n self.state[x, y] = 1\",\n \"def add_point(self, x: int, y: int):\\n self.state[x, y] = 1\",\n \"def add_point(self, x: int, y: int):\\n self.state[x, y] = 1\",\n \"def setPose(self, newPosition):\\n self.origin1 = newPosition\\n self.axis1 = self.G_gl[0:3, 0:3] @ self.axis0\",\n \"def origin():\\n\\n # indices: [axis, point]\\n return numpy.zeros((3, 1))\",\n \"def create(self, pos):\\n self.pos = pos\",\n \"def __init__(self, point=None):\\n\\t\\tif point is None:\\n\\t\\t\\tpoint = (0,0)\\n\\t\\tself.x = point[0]\\n\\t\\tself.y = point[1]\",\n \"def __init__(self, x=0, y=0):\\n self.x = x\\n self.y = y\\n super(Point, self).__init__()\",\n \"def __init__(self, x, y):\\n self.x = x\\n self.y = y\\n self.x1 = self.x + 30 # largeur et hauteur fixees\\n self.y1 = self.y + 30\",\n \"def get_origin(self):\\n return self.coord_cls(x=0, y=0, z=0, system=self)\",\n \"def initialCoordinates():\\r\\n return (-250,-250)\",\n \"def set_drone_position(self, new_point):\\n self.drone.set_drone_position(new_point)\",\n \"def get_origin(self):\\n return self.coord_cls(x=0, y=0, system=self)\",\n \"def get_new_origin(self, direction=None):\\n y, x = 1, 0\\n direction_coords = {'origin': (0, 0), 'right': (0, 1), 'left': (0, -1)}\\n if direction and direction in direction_coords:\\n y, x = direction_coords[direction]\\n return (self.origin[0] + y, self.origin[1] + x)\",\n \"def move_to_origin(x):\\n # Correct x so it is centered at (0,0)\\n tx = np.mean(x[:no_points, :])\\n ty = np.mean(x[no_points:, :])\\n x[:no_points, :] = (x[:no_points, :] - tx)\\n x[no_points:, :] = (x[no_points:, :] - ty)\\n return x, tx, ty\",\n \"def setStartPoint(self, x, y):\\n self._origin = QPointF(x, y)\",\n \"def position(self, x, y):\\n self.x = x \\n self.y = y\\n self.pos[0] = x \\n self.pos[1] = y\",\n \"def new_point(\\n self, data: Union[Tensor, np.ndarray, Sequence[Sequence[float]]]\\n ) -> 'BasePoints':\\n new_tensor = self.tensor.new_tensor(data) \\\\\\n if not isinstance(data, Tensor) else data.to(self.device)\\n original_type = type(self)\\n return original_type(\\n new_tensor,\\n points_dim=self.points_dim,\\n attribute_dims=self.attribute_dims)\",\n \"def add_on_land_position(self) -> Point2:\\n return self.position.offset(Point2((-2.5, 0.5)))\",\n \"def clone(self):\\n return _libsbml.Point_clone(self)\",\n \"def point_at(self, abscissa):\\n return self.zero + abscissa * self.direction\",\n \"def displace(self, (y_offset, x_offset)):\\n ret = copy(self)\\n ret.y += y_offset\\n ret.x += x_offset\\n return ret\",\n \"def __abs__(self) -> PointType:\\n return Point(abs(self.x), abs(self.y))\",\n \"def _transform_point(self, x, y):\\n return (x, y)\",\n \"def reflect_x(self):\\n r_x = self.x\\n r_y = self.y *-1\\n\\n return (Point(r_x,r_y))\",\n \"def newf(self,*args,**kargs): \\n return self._set_coords(coords_func(self.coords,*args,**kargs))\",\n \"def set_origin(self, origin_x, origin_y):\\r\\n self.x = origin_x - (self.rect.width / 2)\\r\\n self.y = origin_y + self.rect.height\\r\\n self._update_rect()\",\n \"def move_origin(self, x, y):\\n return RobotPosition(self.x - x, self.y - y, self.theta)\",\n \"def point_at(self, u, v, world=True):\\n u = u * pi\\n v = v * PI2\\n x = self.radius * cos(u) * sin(v)\\n y = self.radius * sin(u) * sin(v)\\n z = self.radius * cos(v)\\n point = Point(x, y, z)\\n if world:\\n point.transform(self.transformation)\\n return point\",\n \"def translate_to_point_O(self):\\n self.translate(-self.pcs.origin)\",\n \"def copy(self):\\n return Point(self.data, name=self.name+\\\"'\\\")\",\n \"def set_position(self, x, y):\\n self.geometry('%s%s' % (x, y))\",\n \"def to_point(self) -> Point:\\r\\n return Point(self.tile_x * TILE_SIZE, self.tile_y * TILE_SIZE)\",\n \"def create_point(x_crd, y_crd):\\n\\n Point = namedtuple(\\\"Point\\\", \\\"x_crd y_crd\\\")\\n return Point(x_crd, y_crd)\",\n \"def _add_point(self):\\r\\n self.command_stack.do(model.structure.AddPoint(self._structure, self._point_index+1, 0, 0))\",\n \"def reflect_x(self):\\n\\n return Point(self.x, - self.y)\",\n \"def point(self) -> Point:\\n return Point.from_np_array(self.position)\",\n \"def teleport(self, x, y):\\n self.rect.x = x\\n self.rect.y = y\",\n \"def lift(point):\\n return gs.copy(point)\",\n \"def __add__(self, p):\\n return Point(self.x + p.x, self.y + p.y)\",\n \"def spawn(self, y, x, h, w):\\n self.pos = (np.random.randint(y, y + h), np.random.randint(x, x + w))\",\n \"def getNewPosition(self, angle, speed):\\n old_x, old_y = self.getX(), self.getY()\\n # Compute the change in position\\n delta_y = speed * math.cos(math.radians(angle))\\n delta_x = speed * math.sin(math.radians(angle))\\n # Add that to the existing position\\n new_x = old_x + delta_x\\n new_y = old_y + delta_y\\n #print \\\"new x = \\\" + str(new_x) + \\\" new y \\\" + str(new_y)\\n #print \\\"floor of x = \\\" + str(math.floor(new_x)) + \\\" floor of y = \\\" + str(math.floor(new_y))\\n \\n return Position(new_x, new_y)\",\n \"def point_add(self, a, b):\\n\\n if a.at_inf and b.at_inf: return point.inf()\\n if a.at_inf: return b.dup()\\n if b.at_inf: return a.dup()\\n if a == b: return self.point_double(a)\\n if a.x == b.x and a.y == -b.y: return point.inf()\\n\\n x1, y1, x2, y2 = modp(self.p, a.x, a.y, b.x, b.y)\\n L = (y2 - y1) / (x2 - x1)\\n x3 = L ** 2 - x1 - x2\\n y3 = L * (x1 - x3) - y1\\n return point.xy(int(x3), int(y3))\",\n \"def set_position(self, x, y):\\n self.tx = -x\\n self.ty = -y\",\n \"def _moveTo(self, pt):\\n self._handleAnchor()\\n t = \\\"M%s\\\" % (pointToString(pt))\\n self._commands.append(t)\\n self._lastCommand = \\\"M\\\"\\n self._lastX, self._lastY = pt\",\n \"def setPoint(self, point):\\n self.point = point\",\n \"def __init__(self, origin = Vector(0,0,0), color=Colors.White) -> None:\\n self.origin = origin\\n self.color = color\",\n \"def test_shift_point(self):\\n point = (0,0)\\n new_point = utils.shift_point(point, 3, 4)\\n self.assertEqual((3,4), new_point)\\n\\n point = (-2.34, 1.19)\\n new_point = utils.shift_point(point, 2.34, -1.19)\\n self.assertEqual((0,0), new_point)\",\n \"def add(self, point):\\n if not isinstance(point, Point):\\n raise ValueError('Argument point should be an Point instance')\\n self.x = self.x + point.x\\n self.y = self.y + point.y\",\n \"def point(cls, x, y, crs=None):\\n crs = _validate_crs(crs)\\n return cls(arctern.ST_Point(x, y), crs=crs)\",\n \"def place(self,y,x):\\n self.y = y\\n self.x = x\",\n \"def fromPoint(cls, p: Point):\\n return cls(p.coords)\",\n \"def shift_point(mutated_genome,index):\\n Xval = random.randint(-int(imagewidth*0.1),int(imagewidth*0.1))\\n Yval = random.randint(-int(imageheight*0.1),int(imageheight*0.1))\\n point_index = random.randint(0,max(0,len(mutated_genome[index][2])-1))\\n point = mutated_genome[index][2][point_index]\\n newpoint = (point[0]+Xval,point[1]+Yval)\\n mutated_genome[index][2][point_index] = newpoint\",\n \"def point(self, value: Point):\\n self._point = value\",\n \"def new(self, point,ment_id=None):\\n mat = np.zeros((1, np.size(point)))\\n mat[0] = point\\n return CompleteVec(mat, None,self.max_num_samples)\",\n \"def translate_to_origin(shape):\\n s = shape\\n center_x, center_y = Shape.get_centroid(s)\\n for pt in s.pts:\\n pt.x -= center_x\\n pt.y -= center_y\\n return s\",\n \"def setzePosition(self, x, y):\\n self.zielX = x\\n self.zielY = y\",\n \"def set_reference_point(self):\\n theta = 2*math.pi-math.radians(self.REFERENCE_ANGLE)\\n origin_pos = self.locations[0].get_position()\\n target_pos = self.locations[1].get_position()\\n v = self.calculate_displacement(origin_pos, target_pos, transpose=True)\\n v_norm = math.sqrt(v[0]**2+v[1]**2)\\n rotation_matrix = np.matrix([[math.cos(theta), -math.sin(theta)],\\n [math.sin(theta), math.cos(theta)]])\\n offset_x, offset_y = origin_pos\\n reference_point_matrix = np.array([offset_x, offset_y])+np.transpose((1/v_norm)*rotation_matrix*v)\\n self.reference_point = reference_point_matrix.tolist()[0]\",\n \"def location(self, value: 'Point'):\\n self.geometry.location = value\",\n \"def _as_parameter_(self):\\n return POINT(self.x, self.y)\",\n \"def reverse(self):\\n x = self._x * -1\\n y = self._y * -1\\n return Point(x,y)\",\n \"def moveTo(self, pt: Tuple[float, float]) -> None:\\n raise NotImplementedError\",\n \"def __init__(self, pt1, pt2):\\n self.set_points(pt1, pt2)\",\n \"def _adjust_point_to_upperleft(self, layername, point_object):\\n layer_config = self.layers_config[layername]\\n point_position = layer_config[\\\"point_position\\\"]\\n pixel_size = layer_config[\\\"pixel_size\\\"]\\n x, y = point_object\\n if point_position == \\\"upperright\\\":\\n x -= pixel_size\\n elif point_position == \\\"lowerright\\\":\\n x -= pixel_size\\n y -= pixel_size\\n elif point_position == \\\"lowerleft\\\":\\n y -= pixel_size\\n elif point_position == \\\"center\\\":\\n x -= point_position/2.0\\n y -= pixel_size/2.0\\n\\n return Point(x, y, srid=point_object.srid)\",\n \"def transformToOrigin(self):\\n return Transform.shiftOrigin(self.point, self.head)\",\n \"def modifyPoint(self, *args, **kwargs):\\n ...\",\n \"def position(self):\\n return pm.datatypes.Point(self.transform.getTranslation(ws=True))\",\n \"def set_initial_point(self, point):\\r\\n return self._studio.set_initial_point(point)\",\n \"def position(self, create, position=2, **kwargs): # pylint: disable=unused-argument, method-hidden\\r\\n self.position = position\",\n \"def position(self, create, position=2, **kwargs): # pylint: disable=unused-argument, method-hidden\\r\\n self.position = position\",\n \"def add(self, other):\\n x = self._x + other.get_x()\\n y = self._y + other.get_y()\\n return Point(x,y)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6625126","0.6625126","0.652878","0.652878","0.64970213","0.6491764","0.6487044","0.64737606","0.64691556","0.644956","0.6440114","0.63928","0.6373065","0.6364371","0.63607216","0.6351117","0.6336342","0.6333381","0.6307605","0.6301235","0.62239677","0.6207827","0.6206714","0.6201678","0.6191322","0.6183406","0.6177853","0.61457247","0.61246604","0.61176896","0.6101593","0.6101593","0.6101593","0.6088227","0.6082558","0.6079114","0.60741925","0.6050809","0.60158014","0.60124314","0.6004464","0.59938985","0.5991676","0.59877676","0.59726876","0.5964043","0.5949263","0.59482074","0.59429437","0.5942561","0.5939003","0.593655","0.59304625","0.5923469","0.5915776","0.5912839","0.5906663","0.589859","0.58697957","0.58660555","0.58622384","0.5860716","0.5849289","0.5846587","0.58329326","0.58145165","0.58124083","0.5792269","0.577296","0.5763557","0.5756853","0.5747503","0.5745156","0.57391536","0.573236","0.5731722","0.5712127","0.57105917","0.56980693","0.56975955","0.5693514","0.56897914","0.56874585","0.56795615","0.56749785","0.5669597","0.5669481","0.56672174","0.56637836","0.5655645","0.56537807","0.565338","0.56434894","0.56379473","0.56317556","0.5631751","0.5630315","0.5624652","0.56148386","0.56148386","0.5614712"],"string":"[\n \"0.6625126\",\n \"0.6625126\",\n \"0.652878\",\n \"0.652878\",\n \"0.64970213\",\n \"0.6491764\",\n \"0.6487044\",\n \"0.64737606\",\n \"0.64691556\",\n \"0.644956\",\n \"0.6440114\",\n \"0.63928\",\n \"0.6373065\",\n \"0.6364371\",\n \"0.63607216\",\n \"0.6351117\",\n \"0.6336342\",\n \"0.6333381\",\n \"0.6307605\",\n \"0.6301235\",\n \"0.62239677\",\n \"0.6207827\",\n \"0.6206714\",\n \"0.6201678\",\n \"0.6191322\",\n \"0.6183406\",\n \"0.6177853\",\n \"0.61457247\",\n \"0.61246604\",\n \"0.61176896\",\n \"0.6101593\",\n \"0.6101593\",\n \"0.6101593\",\n \"0.6088227\",\n \"0.6082558\",\n \"0.6079114\",\n \"0.60741925\",\n \"0.6050809\",\n \"0.60158014\",\n \"0.60124314\",\n \"0.6004464\",\n \"0.59938985\",\n \"0.5991676\",\n \"0.59877676\",\n \"0.59726876\",\n \"0.5964043\",\n \"0.5949263\",\n \"0.59482074\",\n \"0.59429437\",\n \"0.5942561\",\n \"0.5939003\",\n \"0.593655\",\n \"0.59304625\",\n \"0.5923469\",\n \"0.5915776\",\n \"0.5912839\",\n \"0.5906663\",\n \"0.589859\",\n \"0.58697957\",\n \"0.58660555\",\n \"0.58622384\",\n \"0.5860716\",\n \"0.5849289\",\n \"0.5846587\",\n \"0.58329326\",\n \"0.58145165\",\n \"0.58124083\",\n \"0.5792269\",\n \"0.577296\",\n \"0.5763557\",\n \"0.5756853\",\n \"0.5747503\",\n \"0.5745156\",\n \"0.57391536\",\n \"0.573236\",\n \"0.5731722\",\n \"0.5712127\",\n \"0.57105917\",\n \"0.56980693\",\n \"0.56975955\",\n \"0.5693514\",\n \"0.56897914\",\n \"0.56874585\",\n \"0.56795615\",\n \"0.56749785\",\n \"0.5669597\",\n \"0.5669481\",\n \"0.56672174\",\n \"0.56637836\",\n \"0.5655645\",\n \"0.56537807\",\n \"0.565338\",\n \"0.56434894\",\n \"0.56379473\",\n \"0.56317556\",\n \"0.5631751\",\n \"0.5630315\",\n \"0.5624652\",\n \"0.56148386\",\n \"0.56148386\",\n \"0.5614712\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20178,"cells":{"query":{"kind":"string","value":"method that calls the google maps API."},"document":{"kind":"string","value":"def find_distance(start, end, transit_mode=None):\n dis_url = build_url(start, end, transit_mode)[1]\n print(dis_url)\n json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))\n travel_info = json_response[rows_key][0][elements_key][0]\n distance = travel_info[distance_key][text_key]\n if duration_key in json_response:\n duration = travel_info[duration_traf_key][text_key]\n else:\n duration = travel_info[duration_key][text_key]\n cost = None\n if fare_key in travel_info:\n cost = travel_info[fare_key]\n return duration, distance, cost"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def google_map_api(request):\n\treturn {\n\t\t'GOOGLE_MAPS_API' : settings.GOOGLE_MAPS_API,\n\t}","def googlemaps(request):\n assert False\n # return {\"GOOGLEMAPS_API_KEY\": settings.GOOGLEMAPS_API_KEY}","def google(self):\r\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\r\n middle = '&zoom=14&size=400x400&markers='\r\n suffix = '&key=AIzaSyD5nqmDGFH1SUZxJAYVtFHP7RNjjFE9CHg'\r\n marker = '+'.join(self.placeToSearch) # marker in google format, no space but + separator\r\n request = prefix + marker+middle+marker+suffix\r\n\r\n return request","async def google(self, query):\r\n g_api = \"http://maps.googleapis.com/maps/api/geocode/json?\"\r\n url = g_api + urllib.parse.urlencode({'address': query})\r\n json_data = requests.get(url).json()\r\n formatted_address=json_data['results'][0]['formatted_address']\r\n sat1=json_data['results'][0]['geometry']['location']['lat']\r\n sat2 = json_data['results'][0]['geometry']['location']['lng']\r\n info = discord.Embed(title=query, color=0xefefef)\r\n info.add_field(name=\"\\u200b\", value=formatted_address, inline=False)\r\n info.add_field(name=\"\\u200b\", value=\"Lat:\"+str(sat1), inline=False)\r\n info.add_field(name=\"\\u200b\", value=\"Lng:\"+str(sat2), inline=False)\r\n await self.bot.say(embed=info)","def google_maps(request):\n gmaps_api_key = getattr(settings, 'GOOGLE_MAPS_API', False)\n return {\n 'GOOGLE_MAPS_API': gmaps_api_key,\n 'google_maps': gmaps_api_key\n }","def callGoogle(endpoint: str, params: dict) -> str:\n # hit API \n call = requests.get(endpoint, params=params)\n response = call.json()\n # grab first element in payload\n result: dict = response['results'][0]\n # format lat and lng to a string\n return f\"{result['geometry']['location']['lat']},{result['geometry']['location']['lng']}\"","def api_call(travel_info):\n gmap = googlemaps.Client(key='your-google-maps-api-key')\n\n now = datetime.now()\n try:\n directions_result = gmap.directions(\n travel_info['start_address'],\n travel_info['end_address'],\n mode=travel_info['travel_mode'],\n departure_time=now\n )\n except googlemaps.exceptions.ApiError:\n print('An Error occurred while retrieving directions')\n\n if 'directions_result' in locals() and len(directions_result):\n directions_result = json.dumps(directions_result)\n return json.loads(directions_result)[0]\n else:\n return False","def gmaps_rest(query, mode=\"place\"):\n # https://www.google.com/maps/embed/v1/MODE?key=YOUR_API_KEY¶meters\n base_url = \"https://www.google.com/maps/embed/v1\"\n key = f\"key={_gmaps_key}\"\n q_dict = {\"q\": query, \"zoom\": \"7\"}\n # q = query_encode(urllib.parse.urlencode(q_dict))\n q = urllib.parse.urlencode(q_dict).replace(\"%2C+\", \",\")\n url = f\"{base_url}/{mode}?{key}&{q}\"\n return url","def generate_googlemaps(self):\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = self.tileext\n args['publishurl'] = self.options.url\n args['copyright'] = self.options.copyright\n\n s = r\"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\">\n <head>\n <title>%(title)s</title>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"/>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>\n <script>\n //<![CDATA[\n\n /*\n * Constants for given map\n * TODO: read it from tilemapresource.xml\n */\n\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n var opacity = 0.75;\n var map;\n var hybridOverlay;\n\n /*\n * Create a Custom Opacity GControl\n * http://www.maptiler.org/google-maps-overlay-opacity-control/\n */\n\n var CTransparencyLENGTH = 58;\n // maximum width that the knob can move (slide width minus knob width)\n\n function CTransparencyControl( overlay ) {\n this.overlay = overlay;\n this.opacity = overlay.getTileLayer().getOpacity();\n }\n CTransparencyControl.prototype = new GControl();\n\n // This function positions the slider to match the specified opacity\n CTransparencyControl.prototype.setSlider = function(pos) {\n var left = Math.round((CTransparencyLENGTH*pos));\n this.slide.left = left;\n this.knob.style.left = left+\"px\";\n this.knob.style.top = \"0px\";\n }\n\n // This function reads the slider and sets the overlay opacity level\n CTransparencyControl.prototype.setOpacity = function() {\n // set the global variable\n opacity = this.slide.left/CTransparencyLENGTH;\n this.map.clearOverlays();\n this.map.addOverlay(this.overlay, { zPriority: 0 });\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\n this.map.addOverlay(hybridOverlay);\n }\n }\n\n // This gets called by the API when addControl(new CTransparencyControl())\n CTransparencyControl.prototype.initialize = function(map) {\n var that=this;\n this.map = map;\n\n // Is this MSIE, if so we need to use AlphaImageLoader\n var agent = navigator.userAgent.toLowerCase();\n if ((agent.indexOf(\"msie\") > -1) && (agent.indexOf(\"opera\") < 1)){this.ie = true} else {this.ie = false}\n\n // create the background graphic as a <div> containing an image\n var container = document.createElement(\"div\");\n container.style.width=\"70px\";\n container.style.height=\"21px\";\n\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\";\n container.innerHTML = '<div style=\"height:21px; width:70px; ' +loader+ '\" ></div>';\n } else {\n container.innerHTML = '<div style=\"height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)\" ></div>';\n }\n\n // create the knob as a GDraggableObject\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\";\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.overflow=\"hidden\";\n this.knob_img = document.createElement(\"div\");\n this.knob_img.style.height=\"21px\";\n this.knob_img.style.width=\"83px\";\n this.knob_img.style.filter=loader;\n this.knob_img.style.position=\"relative\";\n this.knob_img.style.left=\"-70px\";\n this.knob.appendChild(this.knob_img);\n } else {\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.backgroundImage=\"url(http://www.maptiler.org/img/opacity-slider.png)\";\n this.knob.style.backgroundPosition=\"-70px 0px\";\n }\n container.appendChild(this.knob);\n this.slide=new GDraggableObject(this.knob, {container:container});\n this.slide.setDraggableCursor('pointer');\n this.slide.setDraggingCursor('pointer');\n this.container = container;\n\n // attach the control to the map\n map.getContainer().appendChild(container);\n\n // init slider\n this.setSlider(this.opacity);\n\n // Listen for the slider being moved and set the opacity\n GEvent.addListener(this.slide, \"dragend\", function() {that.setOpacity()});\n //GEvent.addListener(this.container, \"click\", function( x, y ) { alert(x, y) });\n\n return container;\n }\n\n // Set the default position for the control\n CTransparencyControl.prototype.getDefaultPosition = function() {\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\n }\n\n /*\n * Full-screen Window Resize\n */\n\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n // map.checkResize();\n }\n\n\n /*\n * Main load function:\n */\n\n function load() {\n\n if (GBrowserIsCompatible()) {\n\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\n var gcr = GMapType.prototype.getCopyrights;\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\n return [\"%(copyright)s\"].concat(gcr.call(this,bounds,zoom));\n }\n\n map = new GMap2( document.getElementById(\"map\"), { backgroundColor: '#fff' } );\n\n map.addMapType(G_PHYSICAL_MAP);\n map.setMapType(G_PHYSICAL_MAP);\n\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\n\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\n GEvent.addListener(map, \"maptypechanged\", function() {\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\n map.addOverlay(hybridOverlay);\n } else {\n map.removeOverlay(hybridOverlay);\n }\n } );\n\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\n var mercator = new GMercatorProjection(mapMaxZoom+1);\n tilelayer.getTileUrl = function(tile,zoom) {\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\n return \"http://www.maptiler.org/img/none.png\";\n }\n var ymax = 1 << zoom;\n var y = ymax - tile.y -1;\n var tileBounds = new GLatLngBounds(\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\n );\n if (mapBounds.intersects(tileBounds)) {\n return zoom+\"/\"+tile.x+\"/\"+y+\".png\";\n } else {\n return \"http://www.maptiler.org/img/none.png\";\n }\n }\n // IE 7-: support for PNG alpha channel\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\n tilelayer.isPng = function() { return true;};\n tilelayer.getOpacity = function() { return opacity; }\n\n overlay = new GTileLayerOverlay( tilelayer );\n map.addOverlay(overlay);\n\n map.addControl(new GLargeMapControl());\n map.addControl(new GHierarchicalMapTypeControl());\n map.addControl(new CTransparencyControl( overlay ));\n \"\"\" % args # noqa\n if self.kml:\n s += \"\"\"\n map.addMapType(G_SATELLITE_3D_MAP);\n map.getEarthInstance(getEarthInstanceCB);\n \"\"\"\n s += \"\"\"\n\n map.enableContinuousZoom();\n map.enableScrollWheelZoom();\n\n map.setMapType(G_HYBRID_MAP);\n }\n resize();\n }\n \"\"\"\n if self.kml:\n s += \"\"\"\n function getEarthInstanceCB(object) {\n var ge = object;\n\n if (ge) {\n var url = document.location.toString();\n url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\n var link = ge.createLink(\"\");\n if (\"%(publishurl)s\") { link.setHref(\"%(publishurl)s/doc.kml\") }\n else { link.setHref(url) };\n var networkLink = ge.createNetworkLink(\"\");\n networkLink.setName(\"TMS Map Overlay\");\n networkLink.setFlyToView(true);\n networkLink.setLink(link);\n ge.getFeatures().appendChild(networkLink);\n } else {\n // alert(\"You should open a KML in Google Earth\");\n // add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?\n }\n }\n \"\"\" % args # noqa\n s += \"\"\"\n onresize=function(){ resize(); };\n\n //]]>\n </script>\n </head>\n <body onload=\"load()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"http://www.klokan.cz/projects/gdal2tiles/\">GDAL2Tiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n </body>\n </html>\n \"\"\" % args # noqa\n\n return s","def request_map():\n\n rospy.loginfo(\"Requesting the map\")\n rospy.wait_for_service('dynamic_map')\n getMap = rospy.ServiceProxy('dynamic_map', GetMap)\n g = getMap().map\n\n return g","def test_api_googlemaps(monkeypatch):\n\n def mock_geocode(*args, **kwargs):\n \"\"\"Tips:\n mock_geocode must take as many arguments as the called function\n \"\"\"\n\n return {\n \"latitude\": 48.856614,\n \"longitude\": 2.3522219,\n \"address\": \"Paris, France\"\n }\n\n monkeypatch.setattr(\n GoogleMapsApi, 'geocode', mock_geocode)\n from config import GMAPS_KEY\n gmaps_key = GMAPS_KEY\n api = GoogleMapsApi(gmaps_key)\n api_result = api.geocode(\"Paris\")\n\n assert api_result[\"address\"] == \"Paris, France\"\n assert api_result[\"latitude\"] == 48.856614\n assert api_result[\"longitude\"] == 2.3522219","def test_query_google(self):\n google_api = LocationData()\n latLng = google_api.getLatLong(test_address)\n self.assertEqual(latLng['lat'], 32.625849)","def generate_googlemaps(self):\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = format_extension[self.image_output.format]\n args['publishurl'] = \"\" if self.options.url is None else self.options.url\n args['copyright'] = self.options.copyright\n\n s = \"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\">\n <head>\n <title>%(title)s</title>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"/>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\n <script type=\"text/javascript\">\n //<![CDATA[\n\n /*\n * Constants for given map\n * TODO: read it from tilemapresource.xml\n */\n\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n var opacity = 0.75;\n var map;\n var ge;\n var hybridOverlay;\n\n /*\n * Create a Custom Opacity GControl\n * https://github.com/mj10777/mapmbtilesgoogle-maps-overlay-opacity-control/\n */\n\n var CTransparencyLENGTH = 58;\n // maximum width that the knob can move (slide width minus knob width)\n\n function CTransparencyControl( overlay ) {\n this.overlay = overlay;\n this.opacity = overlay.getTileLayer().getOpacity();\n }\n CTransparencyControl.prototype = new GControl();\n\n // This function positions the slider to match the specified opacity\n CTransparencyControl.prototype.setSlider = function(pos) {\n var left = Math.round((CTransparencyLENGTH*pos));\n this.slide.left = left;\n this.knob.style.left = left+\"px\";\n this.knob.style.top = \"0px\";\n }\n\n // This function reads the slider and sets the overlay opacity level\n CTransparencyControl.prototype.setOpacity = function() {\n // set the global variable\n opacity = this.slide.left/CTransparencyLENGTH;\n this.map.clearOverlays();\n this.map.addOverlay(this.overlay, { zPriority: 0 });\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\n this.map.addOverlay(hybridOverlay);\n }\n }\n\n // This gets called by the API when addControl(new CTransparencyControl())\n CTransparencyControl.prototype.initialize = function(map) {\n var that=this;\n this.map = map;\n\n // Is this MSIE, if so we need to use AlphaImageLoader\n var agent = navigator.userAgent.toLowerCase();\n if ((agent.indexOf(\"msie\") > -1) && (agent.indexOf(\"opera\") < 1)){this.ie = true} else {this.ie = false}\n\n // create the background graphic as a <div> containing an image\n var container = document.createElement(\"div\");\n container.style.width=\"70px\";\n container.style.height=\"21px\";\n\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\";\n container.innerHTML = '<div style=\"height:21px; width:70px; ' +loader+ '\" ></div>';\n } else {\n container.innerHTML = '<div style=\"height:21px; width:70px; background-image: url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\" ></div>';\n }\n\n // create the knob as a GDraggableObject\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\";\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.overflow=\"hidden\";\n this.knob_img = document.createElement(\"div\");\n this.knob_img.style.height=\"21px\";\n this.knob_img.style.width=\"83px\";\n this.knob_img.style.filter=loader;\n this.knob_img.style.position=\"relative\";\n this.knob_img.style.left=\"-70px\";\n this.knob.appendChild(this.knob_img);\n } else {\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.backgroundImage=\"url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\";\n this.knob.style.backgroundPosition=\"-70px 0px\";\n }\n container.appendChild(this.knob);\n this.slide=new GDraggableObject(this.knob, {container:container});\n this.slide.setDraggableCursor('pointer');\n this.slide.setDraggingCursor('pointer');\n this.container = container;\n\n // attach the control to the map\n map.getContainer().appendChild(container);\n\n // init slider\n this.setSlider(this.opacity);\n\n // Listen for the slider being moved and set the opacity\n GEvent.addListener(this.slide, \"dragend\", function() {that.setOpacity()});\n //GEvent.addListener(this.container, \"click\", function( x, y ) { alert(x, y) });\n\n return container;\n }\n\n // Set the default position for the control\n CTransparencyControl.prototype.getDefaultPosition = function() {\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\n }\n\n /*\n * Full-screen Window Resize\n */\n\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n // map.checkResize();\n }\n\n\n /*\n * Main load function:\n */\n\n function load() {\n\n if (GBrowserIsCompatible()) {\n\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\n var gcr = GMapType.prototype.getCopyrights;\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\n return [\"%(copyright)s\"].concat(gcr.call(this,bounds,zoom));\n }\n\n map = new GMap2( document.getElementById(\"map\"), { backgroundColor: '#fff' } );\n\n map.addMapType(G_PHYSICAL_MAP);\n map.setMapType(G_PHYSICAL_MAP);\n\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\n\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\n GEvent.addListener(map, \"maptypechanged\", function() {\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\n map.addOverlay(hybridOverlay);\"\"\" % args\n if self.kml:\n s += \"\"\"\n } else if (map.getCurrentMapType() == G_SATELLITE_3D_MAP) {\n var url = document.location.toString();\n if (url.substr(0,4) != 'http') alert('You have to upload the tiles to a webserver to see the overlay in Google Earth Plugin');\n if (!ge) map.getEarthInstance(getEarthInstanceCB);\"\"\"\n s += \"\"\"\n } else {\n map.removeOverlay(hybridOverlay);\n }\n } );\n\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\n var mercator = new GMercatorProjection(mapMaxZoom+1);\n tilelayer.getTileUrl = function(tile,zoom) {\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n var ymax = 1 << zoom;\n var y = ymax - tile.y -1;\n var tileBounds = new GLatLngBounds(\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\n );\n if (mapBounds.intersects(tileBounds)) {\n return zoom+\"/\"+tile.x+\"/\"+y+\".%(tileformat)s\";\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n // IE 7-: support for PNG alpha channel\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\n tilelayer.isPng = function() { return true;};\n tilelayer.getOpacity = function() { return opacity; }\n\n overlay = new GTileLayerOverlay( tilelayer );\n map.addOverlay(overlay);\n\n map.addControl(new GLargeMapControl3D());\n map.addControl(new GHierarchicalMapTypeControl());\n map.addControl(new CTransparencyControl( overlay ));\n \"\"\" % args\n if self.kml:\n s += \"\"\"\n map.addMapType(G_SATELLITE_3D_MAP);\n \"\"\"\n s += \"\"\"\n\n map.enableContinuousZoom();\n map.enableScrollWheelZoom();\n\n map.setMapType(G_HYBRID_MAP);\n }\n resize();\n }\n \"\"\"\n if self.kml:\n s += \"\"\"\n function getEarthInstanceCB(object) {\n ge = object;\n var url = document.location.toString();\n var newurl = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\n if (ge) {\n var link = ge.createLink(\"\");\n if (\"%(publishurl)s\") { link.setHref(\"%(publishurl)s/doc.kml\") }\n else { link.setHref(newurl) };\n var networkLink = ge.createNetworkLink(\"\");\n networkLink.set(link, false, false);\n ge.getFeatures().appendChild(networkLink);\n } else {\n // alert(\"Initialization of the Google Earth Plugin failed. You can still open the KML file in normal Google Earth.\");\n // window.location = newurl; // JavaScript redirect to the URL of KML\n }\n }\n \"\"\" % args\n s += \"\"\"\n onresize=function(){ resize(); };\n\n //]]>\n </script>\n </head>\n <body onload=\"load()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"https://github.com/mj10777/mapmbtiles\">MapMbTiles</a>/<a href=\"http://www.klokan.cz/projects/gdal2mbtiles/\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n </body>\n </html>\n \"\"\" % args\n\n return s","def _call_geocoder(self, url, raw=False):\n try:\n page = self.urlopen(url)\n except HTTPError as error:\n raise GeocoderServiceError(error.getcode(), getattr(error, 'msg', None))\n if raw:\n return page\n return json.loads(decode_page(page))","def google_geocode(query):\n\tif not API_KEY:\n\t\traise ConfigException(\"Require API_KEY for googleapi. Reload after setting.\")\n\td = {\"address\" : query.encode(\"utf-8\"), \"key\" : API_KEY }\n\tf = urlopen(LOC_URL % (urlencode(d)))\n\tlocdata = load(f)\n\tif f.getcode() == 200:\n\t\tif \"results\" in locdata:\n\t\t\titem = locdata[\"results\"]\n\t\t\tif len(item) == 0:\n\t\t\t\treturn None\n\t\t\titem = item[0]\n\t\t\tll = item.get(\"geometry\", {}).get(\"location\") # lol tricky\n\t\t\tif not ll: return None\n\t\t\treturn item[\"formatted_address\"], ll[\"lat\"], ll[\"lng\"]\n\t\telse:\n\t\t\treturn None\n\telse:\n\t\traise RuntimeError(\"Error (%s): %s\" % (f.getcode(), locdata.replace(\"\\n\", \" \")))","def get_google_results(address, api_key=None, return_full_response=False):\n # Set up your Geocoding url\n geocode_url = \"https://maps.googleapis.com/maps/api/geocode/json?address={}\".format(address) + \"&sensor=false\"\n # if api_key is not None:\n # geocode_url = geocode_url + \"&key={}\".format(api_key)\n\n # Ping google for the reuslts:\n results = requests.get(geocode_url)\n\n # Results will be in JSON format - convert to dict using requests functionality\n results = results.json()\n\n # if there's no results or an error, return empty results.\n if len(results['results']) == 0:\n output = {\n \"formatted_address\": None,\n \"latitude\": None,\n \"longitude\": None,\n \"accuracy\": None,\n \"google_place_id\": None,\n \"type\": None,\n \"postcode\": None\n }\n else:\n answer = results['results'][0]\n output = {\n \"formatted_address\": answer.get('formatted_address'),\n \"latitude\": answer.get('geometry').get('location').get('lat'),\n \"longitude\": answer.get('geometry').get('location').get('lng'),\n \"accuracy\": answer.get('geometry').get('location_type'),\n \"google_place_id\": answer.get(\"place_id\"),\n \"type\": \",\".join(answer.get('types')),\n \"postcode\": \",\".join([x['long_name'] for x in answer.get('address_components')\n if 'postal_code' in x.get('types')])\n }\n\n # Append some other details:\n output['input_string'] = address\n output['number_of_results'] = len(results['results'])\n output['status'] = results.get('status')\n if return_full_response is True:\n output['response'] = results\n\n return output","def get_google_results(api_id, address, return_response_fields=None):\n # set up api key\n api_key = \"AIzaSyDQaVh67imEZW2FLH7hb33SB63jv2shkqQ\"\n request_url = \"\"\n outputs = []\n building = address[0]\n address1 = address[0] + \" \" + address[1] + \" \" + address[2]\n if api_id == \"geocoding\":\n request_url = \"https://maps.googleapis.com/maps/api/geocode/json?address={}\".format(\n address1) + \"&key={}\".format(\n api_key)\n print(\"GEOCODING |||||||||| \" + request_url)\n if api_id == \"nearbysearch\":\n lat_long = get_google_results(\"geocoding\", address, return_response_fields=\"latitude\")[0][\n \"latitude\"].__str__() + \",\" + \\\n get_google_results(\"geocoding\", address, return_response_fields=\"longitude\")[0][\n \"longitude\"].__str__()\n request_url = \"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={}\".format(\n lat_long) + \"&rankby=distance&type=establishment&key={}\".format(api_key)\n print(\"NEARBYSEARCH |||||||||| \" + request_url)\n results = requests.get(request_url)\n results = results.json()\n\n if len(results['results']) == 0:\n return False\n else:\n for answer in results['results']:\n if api_id == \"geocoding\":\n\n street_number = \"0\"\n for y in answer.get('address_components'):\n if 'street_number' in y.get('types'): street_number = y['long_name']\n\n route_name = \"0\"\n for z in answer.get('address_components'):\n if 'route' in z.get('types'): route_name = z['long_name']\n\n output = {\n \"entry\": building,\n \"street_number\": street_number,\n \"route_name\": route_name,\n \"latitude\": answer.get('geometry').get('location').get('lat'),\n \"longitude\": answer.get('geometry').get('location').get('lng'),\n \"google_place_id\": answer.get(\"place_id\"),\n \"type\": \",\".join(answer.get('types')),\n \"postcode\": \",\".join(\n [x['long_name'] for x in answer.get('address_components') if 'postal_code' in x.get('types')]),\n\n }\n if (output[\"route_name\"]) == \"0\":\n output[\"route_name\"] = answer.get('formatted_address')\n if (output[\"street_number\"]) == \"0\":\n\n pattern = re.compile(\"^(.+?),\")\n pattern0 = re.compile(\",(.+?),\")\n patterns = [pattern, pattern0]\n for pat in patterns:\n if pat.search(answer.get('formatted_address')):\n\n ad = re.findall(pat, answer.get('formatted_address'))[0]\n pattern1 = re.compile(\"\\d+\")\n if pattern1.search(ad):\n ad1 = re.findall(pattern1, ad)[0]\n if len(ad1) < 4: output[\"street_number\"] = ad1\n\n outputs += [output]\n\n if api_id == \"nearbysearch\":\n street_number = \"0\"\n route_name = answer.get('vicinity')\n if answer.get('rating') is None:\n rating = 0\n else:\n rating = int(answer.get('rating'))\n\n output = {'input_string': address1, \"street_number\": street_number, \"route_name\": route_name,\n \"google_place_id\": answer.get(\"place_id\"), \"type\": \",\".join(answer.get('types')),\n \"rating\": rating}\n\n pattern = re.compile(\"^(.+?),\")\n pattern0 = re.compile(\",(.+?),\")\n patterns = [pattern, pattern0]\n for pat in patterns:\n if pat.search(route_name):\n\n ad = re.findall(pat, answer.get('vicinity'))[0]\n pattern1 = re.compile(\"\\d+\")\n if pattern1.search(ad):\n ad1 = re.findall(pattern1, ad)[0]\n if len(ad1) < 4: output[\"street_number\"] = ad1\n\n if output[\"street_number\"] == address[0]:\n outputs += [output]\n\n if return_response_fields is None and len(outputs) > 0:\n return outputs\n elif (len(outputs) > 0) and (return_response_fields is not None):\n output_filter = []\n for item in outputs:\n output_filter += [{\"\" + return_response_fields: item[return_response_fields]}]\n outputs = output_filter\n return outputs\n else:\n return False","def test_google_return(monkeypatch):\n ADD = \"7 Cité Paradis, 75010 Paris, France\"\n LAT = 48.8748465\n LNG = 2.3504873\n NAME = \"openclassrooms\"\n RESULTS = {\n \"candidates\": [\n {\n \"formatted_address\": ADD,\n \"geometry\": {\n \"location\": {\n \"lat\": LAT,\n \"lng\": LNG\n },\n\n },\n \"name\": NAME\n\n }\n ]\n\n }\n\n class MockGet:\n def __init__(self,*args, **kwargs):\n pass\n\n def json(self):\n return RESULTS\n\n monkeypatch.setattr('requests.get', MockGet)\n script = GoogleMapApi()\n response = script.search_about_query(query='openclassrooms', g_key=1).json()\n assert response['candidates'][0]['formatted_address'] == ADD","def __init__(self):\n self.service = Client(key=GEO_LOCATION_API_KEY)","def main():\r\n # establishes start end and time data\r\n query_user()\r\n # returns optimal subway stop\r\n subway_stop_location = determine_optimal_CTA()\r\n # returns the time you need to arrive at the CTA\r\n arrival_time_transit = determine_arrival_time(subway_stop_location)\r\n # launches directions in google maps, with two windows for directions to and from CTA\r\n # launch_directions(arrival_time_transit, subway_stop_location)\r","def small_map(self):\n self.map_url = \"https://maps.googleapis.com/maps/api/staticmap?center={},{}&zoom=12&size=350x350&key={}\".format(self.lat, self.lng, api_key) \n return (self.map_url)","def get_google_geocoding(coordinates):\n latitude = coordinates['latitude']\n longitude = coordinates['longitude']\n payload = build_google_payload(latitude=latitude, longitude=longitude)\n response = requests.get(google_url, params=payload, timeout=int(GEOCODING_INFO['timeout']))\n if response.status_code == 200:\n formated_data = extract_data_from_google_response(response.text.encode('utf-8'))\n return formated_data\n else:\n return None","def get_google_results(address):\n\t# Set up your Geocoding url\n\tlogging.info(\"[GOOGLE URL]: init\")\n\tparams = {\n\t\"address\":address,\n\t\"key\":GEOPY.get('AQUEDUCT_GOOGLE_PLACES_PRIVATE_KEY')\n\t}\n\t\n\t# Ping google for the reuslts:\n\ttry:\n\t\twith requests.Session() as s:\n\t\t\ts.mount('https://',HTTPAdapter(max_retries=Retry(2, backoff_factor=0.001)))\n\t\t\tr = s.get(url=GEOCODE_URL, params=params, timeout=5)\n\t\t\n\t\tif r.status_code == requests.codes.ok:\n\t\t\t# Results will be in JSON format - convert to dict using requests functionality\n\t\t\tresults = r.json()\n\t\t\t# if there's no results or an error, return empty results.\n\t\t\tif len(results['results']) == 0:\n\t\t\t\toutput = {\n\t\t\t\t\t\"matched_address\" : None,\n\t\t\t\t\t\"lat\": None,\n\t\t\t\t\t\"lon\": None,\n\t\t\t\t\t\"match\": False\n\t\t\t\t}\n\t\t\telse: \n\t\t\t\tanswer = results['results'][0]\n\t\t\t\toutput = {\n\t\t\t\t\t\"matched_address\" : answer.get('formatted_address'),\n\t\t\t\t\t\"lat\": answer.get('geometry').get('location').get('lat'),\n\t\t\t\t\t\"lon\": answer.get('geometry').get('location').get('lng'),\n\t\t\t\t\t\"match\":True\n\t\t\t\t}\n\t\telse:\n\t\t\tlogging.error(f\"[GEOCODER: Get google place]: {r.text}\")\n\t\t\tlogging.error(f\"[GEOCODER- GOOGLE URL]: {r.status_code}\")\n\t\t\toutput = {\n\t\t\t\t\"matched_address\" : None,\n\t\t\t\t\"lat\": None,\n\t\t\t\t\"lon\": None,\n\t\t\t\t\"match\": False\n\t\t\t}\n\t\t\t\n\t\t# Append some other details: \n\t\toutput['address'] = address\n\t\toutput['number_of_results'] = len(results['results'])\n\t\toutput['status'] = results.get('status')\n\t\t\n\t\treturn output\n\texcept Exception as e:\n\t\traise e","def test_view_geocoder_success(self, google):\n google.return_value = GeocoderMock()\n\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\n\n response = view.geocode_location('Test, Test')\n\n # Check geocoder returns a list of [0,1]\n self.assertListEqual(response, [0,1])","def scrapping():\r\n\r\n data_cust = {}\r\n #token, latitude, longitude, name, place_id, types_places, vicinity = [],[],[],[],[],[], []\r\n\r\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\r\n urls = 'https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={},{}&radius={}&key={}&type={}&keyword={}'.format(\r\n lat_ori, long_ori, radius, apik, types_user, keyword_user)\r\n r = requests.get(urls)\r\n data_cust['0'] = r.json()\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n CODE FOR NEXT PAGE TOKEN\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n for number in range(10):\r\n\r\n content = str(number)\r\n if 'next_page_token' in data_cust[content].keys():\r\n sleep(5)\r\n pagetoken = data_cust[content]['next_page_token']\r\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\r\n urls = 'https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={},{}&radius={}&type={}&keyword={}&key={}{pagetoken}'.format(\r\n lat_ori, long_ori, radius, types_user, keyword_user, apik, pagetoken=\"&pagetoken=\"+pagetoken if pagetoken else \"\")\r\n r = requests.get(urls)\r\n get = requests.post(urls)\r\n print(get)\r\n new_id = str(number+1)\r\n data_cust[new_id] = r.json()\r\n else:\r\n print(\"Done\")\r\n break\r\n\r\n latitude, longitude, name, place_id, types_places, vicinity = [], [], [], [], [], []\r\n for i in range(number+1):\r\n content = str(i)\r\n for numbers in range(len(data_cust[content]['results'])):\r\n latitude.append(data_cust[content]['results']\r\n [numbers]['geometry']['location']['lat'])\r\n longitude.append(data_cust[content]['results']\r\n [numbers]['geometry']['location']['lng'])\r\n name.append(data_cust[content]['results'][numbers]['name'])\r\n place_id.append(data_cust[content]['results'][numbers]['place_id'])\r\n types_places.append(\r\n data_cust[content]['results'][numbers]['types'][0])\r\n vicinity.append(data_cust[content]['results'][numbers]['vicinity'])\r\n\r\n datacustype = pd.DataFrame({'customer_name': name, 'customer_type': types_places, 'place_id': place_id,\r\n 'keyword': keyword_user, 'radius': radius, 'latitude_origin': lat_ori, 'longitude_origin': long_ori, 'latitude_destination': latitude,\r\n 'longitude_destination': longitude})\r\n datacustype\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n PHONE NUMBER\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n data_number = {}\r\n for number in datacustype['place_id'].values:\r\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\r\n urls = 'https://maps.googleapis.com/maps/api/place/details/json?place_id={}&fields=name,formatted_address,rating,formatted_phone_number&key={}'.format(\r\n number, apik)\r\n r = requests.get(urls)\r\n data_number[number] = r.json()\r\n\r\n data_number\r\n\r\n datanumb = pd.DataFrame.from_dict(data_number).T.reset_index()\r\n datanumb.columns = ['place_id', 'html_attributions', 'result', 'status']\r\n datanumb\r\n\r\n name, phone, alamat = [], [], []\r\n\r\n for number in range(len(datanumb)):\r\n if datanumb['status'][number] == 'NOT_FOUND':\r\n name.append('Unknown')\r\n phone.append(0)\r\n alamat.append('-')\r\n else:\r\n name.append(datanumb['result'][number]['name'])\r\n alamat.append(datanumb['result'][number]['formatted_address'])\r\n if 'formatted_phone_number' in (datanumb['result'][number].keys()):\r\n phone.append(datanumb['result'][number]\r\n ['formatted_phone_number'])\r\n else:\r\n phone.append(0)\r\n\r\n datanumb2 = pd.DataFrame(\r\n {'customer_name': name, 'customer_address': alamat, 'phone_number': phone})\r\n datanumb2['place_id'] = datanumb['place_id']\r\n datanumb2\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n DATA MERGE\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n datamerge = datacustype.merge(datanumb2, how='left', on='place_id')\r\n datamerge\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n DUMMY\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n datadummy = datamerge.copy()\r\n datadummy\r\n\r\n datadummydrop = datadummy.drop(['customer_name_y'], axis=1)\r\n datadummydrop.rename(\r\n columns={'customer_name_x': 'customer_name'}, inplace=True)\r\n datadummydrop2 = datadummydrop[['customer_name', 'customer_address', 'customer_type', 'keyword', 'radius',\r\n 'place_id', 'latitude_origin', 'longitude_origin', 'latitude_destination', 'longitude_destination', 'phone_number']]\r\n datadummydrop2\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n DISTANCE MATRIX\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n API_key = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E' # enter Google Maps API key\r\n gmaps = googlemaps.Client(key=API_key)\r\n\r\n distancedrive, distancewalks = [], []\r\n\r\n # Loop through each row in the data frame using pairwise\r\n for number in range(datadummydrop2.shape[0]):\r\n # Assign latitude and longitude as origin/departure points\r\n LatOrigin = datadummydrop2['latitude_origin'][number]\r\n LongOrigin = datadummydrop2['longitude_origin'][number]\r\n origins = (LatOrigin, LongOrigin)\r\n\r\n # Assign latitude and longitude from the next row as the destination point\r\n # Save value as lat\r\n LatDest = datadummydrop2['latitude_destination'][number]\r\n # Save value as lat\r\n LongDest = datadummydrop2['longitude_destination'][number]\r\n destination = (LatDest, LongDest)\r\n\r\n # pass origin and destination variables to distance_matrix function# output in meters\r\n result = gmaps.distance_matrix(origins, destination, mode='driving', avoid='tolls',\r\n units='metric', departure_time=1703981100)[\"rows\"][0][\"elements\"][0][\"distance\"][\"value\"]\r\n # 1703981100 #1606867500\r\n # append result to list\r\n distancedrive.append(result)\r\n\r\n datadummydrop2['distance_driving'] = distancedrive\r\n datadummydrop3 = datadummydrop2.sort_values(\r\n by=['distance_driving'], ascending=True, ignore_index=True)\r\n datadummydrop3\r\n\r\n \"\"\"\r\n /////////////////////////////////////////////////////////////////////////////\r\n\r\n DATAFRAME TO POSTGRE\r\n\r\n /////////////////////////////////////////////////////////////////////////////\r\n \"\"\"\r\n\r\n database = psycopg2.connect(database=\"customerDB\",\r\n user=\"postgres\",\r\n password=\"1234\",\r\n host=\"localhost\")\r\n\r\n cursor = database.cursor()\r\n\r\n for i in datadummydrop3.index:\r\n c1 = datadummydrop3['customer_name'][i]\r\n c2 = datadummydrop3['customer_address'][i]\r\n c3 = datadummydrop3['customer_type'][i]\r\n c4 = datadummydrop3['keyword'][i]\r\n c5 = datadummydrop3['radius'][i]\r\n c6 = datadummydrop3['place_id'][i]\r\n c7 = datadummydrop3['latitude_origin'][i]\r\n c8 = datadummydrop3['longitude_origin'][i]\r\n c9 = datadummydrop3['latitude_destination'][i]\r\n c10 = datadummydrop3['longitude_destination'][i]\r\n c11 = datadummydrop3['phone_number'][i]\r\n c12 = datadummydrop3['distance_driving'][i]\r\n query = \"\"\"\r\n Insert into customertarget_customerpotential(customer_name, customer_address, customer_type, keyword, radius, place_id, latitude_origin, longitude_origin, latitude_destination, longitude_destination, phone_number, distance_driving) VALUES('%s','%s','%s','%s','%s','%s',%s,%s,%s,%s,'%s',%s);\r\n \"\"\" % (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)\r\n cursor.execute(query)\r\n cursor.close()\r\n\r\n database.commit()\r\n database.close()\r\n\r\n print(\"Data berhasil di upload\")","def send_map_data():\n\n avg_lat = 37.75774\n avg_long = -122.43870\n bounds = {'lat': [-122.54, -122.35], 'lng': [37.67, 37.84]}\n center = {'lat': avg_lat, 'lng': avg_long}\n\n return jsonify({'map_center': center,\n 'map_bounds': bounds,\n })","def query_google(lat='38.890762', lon='-77.084755', radius='400', keywords=['coffee', 'cafe', 'brunch']):\n base_url = \"https://maps.googleapis.com/maps/api/place/nearbysearch/json\"\n location = f\"{lat}, {lon}\"\n for kw in keywords:\n params = {\n \"key\": codecs.decode(config['google']['api_key'], 'rot-13'),\n \"type\": 'food',\n \"rankby\": 'prominence',\n \"location\": location,\n \"radius\": radius,\n \"keyword\": kw\n }\n\n try:\n response = requests.get(base_url, params=params).json()\n key_results_list = response['results']\n except Exception as e:\n print(f'error in query_google {e}')\n\n #passes to this point\n print(f'query_google - key_results_list: {key_results_list}')\n\n if \"next_page_token\" in response:\n params = {\n \"key\": codecs.decode(config['google']['api_key'], 'rot-13'),\n \"type\": 'food',\n \"rankby\": 'prominence',\n \"location\": location,\n \"radius\": radius,\n \"keyword\": kw,\n \"pagetoken\": response[\"next_page_token\"]\n }\n\n response_next_page = requests.get(base_url, params=params).json()\n key_results_list = key_results_list + response_next_page['results']\n print(response_next_page)\n\n else:\n print(\"no next page\")\n\n for kr in key_results_list:\n kr[\"keyword\"] = kw\n print(f'key results list length is: {len(kr)}')\n\n #db.get_collection(\"google_places\").delete_many({}) # This needs to be moved into Flask to aggregate results\n db.get_collection(\"google_places\").insert_many(key_results_list)","def geocodeLocations(locations):\n maxResults = 1\n location_query = ''\n for location in locations:\n location_query += \"&location=%s\" % encodeUrl(location)\n url = \"http://open.mapquestapi.com/geocoding/v1/batch?maxResults=%d%s\" % (maxResults, location_query)\n print url\n results = json.loads(urllib2.urlopen(url).read())\n print results\n return\n for location_result in results['results']:\n #print location_result\n if location_result['providedLocation']['location'] == location:\n latlng = location_result['locations'][0]['displayLatLng']\n return latlng\n else:\n print location_result","def __init__(self, locality=False):\n self.google = googlemaps.Client(key=os.environ['GOOGLE_API_KEY'])\n\n if locality:\n self.bounds = self.bound(locality)\n self.northeast, self.southwest = self.nad83(self.bounds.northeast), self.nad83(self.bounds.southwest)\n self.geography = self.grid(self.northeast, self.southwest)\n\n return None","def test_get_place(self):\n req_data = jsonify({\"lat\": 28.615551,\n \"long\": 77.224091})\n res = req.post(get_place_url, json=req_data)\n self.assertEqual(\"200\", json.loads(res.text)[\"Status\"])","def __init__(self, place):\n self.place = place\n self.cleanplace = parser(self.place)\n self.key = googlemaps.Client(key=os.environ.get(\"GMAP_KEY\") or GMAP_KEY)\n self.response = self.search()\n self.latitude = self.response[0][\"geometry\"][\"location\"][\"lat\"]\n self.longitude = self.response[0][\"geometry\"][\"location\"][\"lng\"]\n self.address = self.response[0][\"formatted_address\"]\n self.wiki = self.response[0][\"address_components\"][1][\"long_name\"]","def get_static_google_map(filename_wo_extension, center=None, zoom=None, imgsize=\"640x640\", imgformat=\"png\",\n maptype=\"roadmap\", markers=None):\n\n # assemble the URL\n # base URL, append query params, separated by &\n request = \"http://maps.google.com/maps/api/staticmap?\"\n apiKey = os.getenv('GOOGLE_MAPS_API_KEY')\n # if center and zoom are not given, the map will show all marker locations\n request += \"key=%s&\" % apiKey\n if center != None:\n request += \"center=%s&\" % center\n if zoom != None:\n # zoom 0 (all of the world scale ) to 22 (single buildings scale)\n request += \"zoom=%i&\" % zoom\n\n request += \"size=%ix%i&\" % (imgsize) # tuple of ints, up to 640 by 640\n request += \"format=%s&\" % imgformat\n request += \"bearing=90&\"\n # request += \"maptype=%s&\" % maptype # roadmap, satellite, hybrid, terrain\n\n # add markers (location and style)\n if markers != None:\n for marker in markers:\n request += \"%s&\" % marker\n\n request = request.rstrip('&')\n # #request += \"mobile=false&\" # optional: mobile=true will assume the image is shown on a small screen (mobile device)\n # request += \"sensor=false\" # must be given, deals with getting loction from mobile device\n # try:\n urllib.request.urlretrieve(request, filename_wo_extension)","def maps(request):\n #convert image locations to google maps parsable points\n now = datetime.utcnow().replace(tzinfo=utc)\n latlngs = search_utils.filter_date(search_utils.min_date, now)\n points = [search_utils.to_map_point(image) for image in latlngs]\n #load the search form sidebar\n t = loader.get_template(\"wainz/search_form.html\")\n ctx = Context({})\n search_form = t.render(ctx)\n\n return render_to_response('wainz/maps.html', {\"latLngs\":points, \"search_form\":search_form, \"typeAheadTags\":Tag.objects.all()}, context_instance = RequestContext(request))","def geocode():\n\n if \"location\" in request.vars:\n location = request.vars.location\n else:\n session.error = T(\"Need to specify a location to search for.\")\n redirect(URL(r=request, f=\"index\"))\n\n if \"service\" in request.vars:\n service = request.vars.service\n else:\n # @ToDo: service=all should be default\n service = \"google\"\n\n if service == \"google\":\n return s3base.GoogleGeocoder(location, db).get_kml()\n\n if service == \"yahoo\":\n return s3base.YahooGeocoder(location, db).get_xml()","def send_request(origin_addresses, dest_addresses, api):\n def build_address_str(addresses):\n # Build a pipe-separated string of addresses\n address_str = ''\n for i in range(len(addresses) - 1):\n address_str += addresses[i] + '|'\n address_str += addresses[-1]\n return address_str\n\n request = 'https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial'\n origin_address_str = build_address_str(origin_addresses)\n dest_address_str = build_address_str(dest_addresses)\n request = request + '&origins=' + origin_address_str + '&destinations=' + \\\n dest_address_str + '&key=' + api\n jsonResult = urllib.request.urlopen(request).read().decode(\"utf-8\")\n response = json.loads(jsonResult)\n return response","def ajax_solve():\n\n # The possible errors and their human-readable messages\n ERRORS = {\n 403: \"Google Directions could not find a path\",\n 404: \"Google Directions did not send response\",\n 405: \"You did not specify a start\",\n 406: \"You need to specify at least two waypoints\",\n 407: \"You did not specify a valid algorithm\",\n 408: \"Internal Algorithm Error\",\n\n }\n\n\n def to_tuple(waypoint):\n \"\"\"\n Converts LatLng dicts to tuples.\n\n :param waypoint: A waypoint as string, tuple or LatLng dict\n :return: waypoint, if waypoint is string or tuple,\n a tuple of the lat and lng values, if dict\n\n \"\"\"\n if isinstance(waypoint, dict):\n return (waypoint[\"lat\"], waypoint[\"lng\"])\n else:\n return waypoint\n\n def to_dict(waypoint):\n \"\"\"\n Converts to tuples to LatLng dicts.\n\n :param waypoint: A waypoint as string or tuple\n :return: waypoint, if waypoint is string or tuple,\n a LatNg dict, if tuple\n \"\"\"\n if isinstance(waypoint, tuple):\n return {\"lat\": waypoint[0], \"lng\": waypoint[1]}\n else:\n return waypoint\n\n\n\n # Get the arguments\n json = request.args\n\n # Check that a start point is supplied\n start = json.get(\"origin\")\n if not start:\n return jsonify(status=406, msg=ERRORS[405])\n\n # Convert to tuple if necessary\n # This is needed to store waypoints as keys in a dict\n start = to_tuple(start)\n\n\n\n waypoints = json.getlist(\"waypoints[]\")\n if not waypoints:\n return jsonify(status=406, msg=ERRORS[406])\n\n # We need to have at least two points for a path\n if len(waypoints) < 2:\n return jsonify(status=406, msg=ERRORS[406])\n\n # Convert to tuple if necessary\n # This is needed to store waypoints as keys in a dict\n waypoints = map(to_tuple, waypoints)\n\n # Get the algorithm\n algorithm = algorithms[json[\"algo\"]]\n if not algorithm:\n return jsonify(status=407, msg=ERRORS[407])\n\n # Get the options\n options = {}\n for option in algorithm.options():\n options[option] = float(json.get(\"options[%s]\" % option))\n\n try:\n distances = matrix.create(waypoints)\n except BaseException as e:\n logging.warning(\"Exception %s while creating matrix for %s\" % (e, waypoints))\n return jsonify(status=404, msg=ERRORS[404])\n else:\n if distances:\n\n try:\n # Call the algorithm\n l, path = algorithm.solve(start, distances, **options)\n except BaseException as e:\n logging.warning(\"Exception %s while executing %s with %s\" % (e, algorithm.name, options))\n return jsonify(status=408, msg=ERRORS[408])\n else:\n # Pack result\n result = {\n \"status\": 200,\n \"length\": l,\n \"start\": start,\n \"algo\": json[\"algo\"],\n \"path\": map(to_dict, path),\n \"msg\": \"SUCCESS\"\n }\n\n # Return the result\n return jsonify(result)\n else:\n return jsonify(status=403, msg=ERRORS[403])","def __init__(self, lat, lon, api):\n self.lat = lat\n self.lon = lon\n self.api = api\n self.result = {}","def GoogleAPIele(self):\n import urllib.request\n import json\n \n self.elevation = []\n Base_url = \"https://maps.googleapis.com/maps/api/elevation/json?locations=\"\n APIkey = \"&key=AIzaSyDOo1DAojYoYf3WCcadLrsl9PZbnougbtE\"\n \n for i in range(self.nodenum):\n Para_url = \"%s,%s\" % (self.latitude[i], self.longitude[i])\n url = Base_url + Para_url + APIkey\n \n with urllib.request.urlopen(url) as f:\n response = json.loads(f.read().decode())\n \n self.elevation.append(response['results'][0]['elevation'])","async def gethotelsinfo(url, key):\n async with aiohttp.ClientSession() as client:\n response = await client.request('GET', url)\n text = await response.read()\n # we create a google maps object.\n gmaps = googlemaps.Client(key=key)\n parser = BeautifulSoup(text, 'html.parser')\n current_timestamp_utc = datetime.utcnow()\n hotelreview = {}\n hotelreview.update({'url':url,'insert_time_utc':current_timestamp_utc})\n # name\n try:\n name = parser.find(class_=\"heading_title\").get_text()\n title = re.sub('\\n', '', name)\n except:\n title = None\n hotelreview.update({'title':title})\n # address\n try:\n address = parser.find(class_=\"content hidden\").get_text('')\n except:\n address = None\n hotelreview.update({'address':address})\n # latitude and longitude\n if address is None:\n latitude = None\n longitude = None\n hotelreview.update({'location': None})\n else:\n try:\n # we make the request to the google maps API.\n geocode_result = gmaps.geocode(address)\n latitude = geocode_result[0]['geometry']['location']['lat']\n longitude = geocode_result[0]['geometry']['location']['lng']\n hotelreview.update({'location': str(latitude) + ',' + str(longitude)})\n except:\n latitude = None\n longitude = None\n hotelreview.update({'location':None})\n # zipcode.\n try:\n raw_zipcode = parser.find(class_=\"content hidden\").find(class_=\"locality\").get_text('')\n zipcode = int(raw_zipcode.split(' ')[0])\n except:\n zipcode = None\n hotelreview.update({'zipcode':zipcode})\n # city\n try:\n raw_city = parser.find(class_=\"content hidden\").find(class_=\"locality\").get_text('')\n city = raw_city.split(' ')[1].replace(',', '')\n except:\n city = None\n hotelreview.update({'city':city})\n # rooms\n try:\n numberofrooms = int(parser.find(class_=\"list number_of_rooms\").get_text(';').split(';')[1])\n except:\n numberofrooms = None\n hotelreview.update({'numberofrooms':numberofrooms})\n # stars\n try:\n stars = parser.find(class_=\"starRating detailListItem\").get_text(';').split(';')[1]\n except:\n stars = None\n hotelreview.update({'stars':stars})\n # services\n try:\n service = str([i.get_text(';') for i in parser.find(class_=\"detailsMid\").\n findAll(class_=\"highlightedAmenity detailListItem\")]).replace(\"'\", \"\")\n except:\n service = None\n hotelreview.update({'service':service})\n # price\n try:\n prices = parser.find(class_=\"list price_range\").get_text(';').replace('\\xa0', '')\n minprice = int(prices.split(';')[1].split('€')[0])\n maxprice = int(prices.split(';')[1].split('-')[1].split(\"€\")[0])\n except:\n minprice = None\n maxprice = None\n hotelreview.update({'minprice':minprice})\n hotelreview.update({'maxprice':maxprice})\n #phonenumber\n try:\n phone = parser.find(class_=\"blEntry phone\").get_text()\n parse_phone = \"\".join(phone.split())\n except:\n parse_phone = None\n hotelreview.update({'parse_phone':parse_phone})\n return hotelreview","def get_lat_lng(self):\n self.input_api = '%20'.join(self.parsed_question)\n self.input_api = ' '.join(self.parsed_question)\n self.google_api_url = 'https://maps.googleapis.com/maps/api/place/findplacefromtext/json?input={}&inputtype=textquery&fields=geometry,name,place_id&types=point_of_interest&key={}'.format (self.input_api, api_key) \n self.r = requests.get(url=self.google_api_url)\n self.data = self.r.json()\n self.name = self.data['candidates'][0]['name']\n self.place_id = self.data['candidates'][0]['place_id']\n self.lat = self.data['candidates'][0]['geometry']['location']['lat']\n self.lng = self.data['candidates'][0]['geometry']['location']['lng']\n print(self.lat, self.lng, self.place_id)\n return (self.lat, self.lng, self.place_id)","def get_lat_lng(apiKey,address):\n \n url = ('https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}'\n .format(address.replace(' ','+'), apiKey))\n try:\n response = requests.get(url)\n resp_json_payload = response.json()\n lat = resp_json_payload['results'][0]['geometry']['location']['lat']\n lng = resp_json_payload['results'][0]['geometry']['location']['lng']\n except:\n print('ERROR: {}'.format(address))\n lat = 0\n lng = 0\n return lat, lng","def main(self):\n question = Parser(self.question)\n latitude = 0\n longitude = 0\n address = \"Bonjour, je vais bien merci !\"\n history = self._get_papy_sentence()\n article_title = \"\"\n location = question.get_location()\n google = GoogleApi(location, self.google_key)\n google_response = google.parse()\n if question.get_verification():\n latitude = google_response['latitude']\n longitude = google_response['longitude']\n address = google_response['address']\n if google_response['status'] == \"OK\":\n wiki = WikiApi(google_response['latitude'],\n google_response['longitude'])\n wiki_response = wiki.parse()\n if wiki_response['status'] == \"OK\":\n history = wiki_response['history']\n article_title = wiki_response['article_title']\n\n self.response_grandpy = {\n 'latitude': latitude,\n 'longitude': longitude,\n 'address': address,\n 'history': history,\n 'article_title': article_title\n }\n return self.response_grandpy","def main(postalcode):\n places = postalcodes_mexico.places(postalcode)\n click.echo(places)\n return 0","def test_doGet(self) -> None:\n\n status_code = apicall.doGet(URL, self._browserheader)\n print(\"in do get:\", status_code)\n assert status_code == API_SUCCESS","def main(name):\n user_dict = twitter_api.main(name)\n if user_dict == \"\":\n return \"no_name\"\n user_points_dict = coordinates.convert_to_coordinates(user_dict)\n map.create_map(user_points_dict, name)","def main():\n\ttile_dimensions = (512, 512)\n\ttile_count = (5, 4) \n\timage = Image.new(\"RGB\", (tile_dimensions[0] * tile_count[0], tile_dimensions[1] * tile_count[1]), None)\n\n\ttry:\n\t\turl = sys.argv[1]\n\texcept:\n\t\tprint \"Please enter a Google Maps URL as a parameter.\"\n\t\tprint \"Usage: $ python get_pano.py https://www.google.com/maps/@34.1027387,-118.340471,3a,75y,32.1h,87.53t/data=!3m7!1e1!3m5!1soInaTCic7TsAAAQDMaZ31A!2e0!3e2!7i13312!8i6656\"\n\t\treturn\n\n\ttry:\n\t\tprint \"************************************\"\n\t\tprint \"Fetching images from Google Maps, this could take some time...\"\n\t\tregex = re.compile(r'panoid\\=([^&]*)', re.I)\n\t\tpano_id = regex.findall(urllib.unquote(url))[0]\n\t\tfor y in range(tile_count[1]):\n\t\t\tfor x in range(tile_count[0]):\n\t\t\t\timg_url = \"https://geo2.ggpht.com/cbk?cb_client=maps_sv.tactile&authuser=0&hl=en&panoid=\" + pano_id + \"&output=tile&x=\"+str(x)+\"&y=\"+str(y)+\"&zoom=3&nbt&fover=2\"\n\t\t\t\tresponse = urllib2.urlopen(img_url)\n\t\t\t\tfile_data = StringIO(response.read())\n\t\t\t\timage.paste(Image.open(file_data), (x * tile_dimensions[0], y * tile_dimensions[1]))\n\t\t\n\t\tfilename = \"pano-\" + pano_id + \".jpg\"\n\t\timage.save(filename)\n\t\tprint \"Success, image saved as \\033[96m\" + filename + \"\\033[00m\"\n\t\tprint \"************************************\"\n\n\n\texcept Exception as e:\n\t\tprint \"Sorry something broke.\"\n\t\tprint e","def __geo_interface__(self):\n ...","def walking():\r\n name = request.args[\"address\"]\r\n end_name=request.args[\"end_point\"]\r\n end_lng = request.args[\"end_lng\"]\r\n end_lat = request.args[\"end_lat\"]\r\n end_lng = float(end_lng)\r\n end_lat = float(end_lat)\r\n start_lng=get_address(name)[1]\r\n start_lat=get_address(name)[0]\r\n\r\n\r\n #get coordinates of start and end point\r\n map_directions, geojson_str = get_static_map(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n logging.warning(\"Map directions %s\", str(map_directions))\r\n\r\n\r\n #retrieve instructions\r\n instructions = get_map_instructions(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n\r\n\r\n # generate interactive map\r\n return render_template(\r\n \"page4.html\",\r\n mapbox_token=MAPBOX_TOKEN,\r\n geojson_str=geojson_str,\r\n end_name=end_name,\r\n name=name,\r\n start_lng=start_lng,\r\n start_lat=start_lng,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n center_lng=(start_lng + end_lng) / 2,\r\n center_lat=(start_lat + end_lat) / 2,\r\n instructions=instructions,\r\n method = 'Walking'\r\n )","def process(self):\n if self.user is not None:\n async_queries = []\n \n # DEBUGGING\n # prefs = []\n \n # Load in preferences\n for k, v in self.user.preferences.iteritems():\n for l in self.user.preferences[k]:\n gmap_search = GoogleMapSearch()\n gmap_search.parameters['location'] = '40,-88'\n gmap_search.parameters['radius'] = '10000'\n gmap_search.parameters['keyword'] = l\n gmap_search.parameters['language'] = 'en'\n # gmap_search.parameters['minprice'] = None\n # gmap_search.parameters['maxprice'] = None\n # gmap_search.parameters['name'] = None\n # gmap_search.parameters['opennow'] = None\n # gmap_search.parameters['rankby'] = None\n if k != 'keywords': gmap_search.parameters['types'] = k\n # gmap_search.parameters['pagetoken'] = None\n \n # DEBUGGING\n # prefs.append(gmap_search.parameters)\n \n async_queries.append(gmap_search)\n \n # Send all requests\n async_pool = Pool(processes=8)\n response = async_pool.map(parallel_search, async_queries)\n filtered_responses = ['']*len(response)\n for i, r in enumerate(response):\n filtered_response = {k:v for (k, v) in r.iteritems()}\n filtered_response['category'] = {'name': None, 'type': None}\n if async_queries[i].parameters.has_key('type') and async_queries[i].parameters['types'] != '' and async_queries[i].parameters['types'] is not None: filtered_response['category']['name'] = async_queries[i].parameters['types']\n else: filtered_response['category']['name'] = 'keyword'\n filtered_response['category']['type'] = async_queries[i].parameters['keyword']\n filtered_responses[i] = filtered_response\n return json.dumps(filtered_responses)\n else: return None","def main():\n #get_lat_long\n place_name = 'Arlington - Arlington St'\n # sec_fun = get_lat_long(place_name)\n # print(sec_fun)\n # get_nearest_station(sec_fun[0], sec_fun[1]) #\n # get_nearest_station(42.350009, -71.076077)\n print(find_stop_near(place_name))","def pull_data_from_google(credentials):\n pass","def map_viewing_client():\n\n # Read configuration settings\n config = gis.get_config()\n if config.opt_gis_layout == 1:\n window = True\n else:\n window = False\n\n # @ToDo Make Configurable\n toolbar = True\n\n map = define_map(window=window, toolbar=toolbar, config=config)\n\n response.title = T(\"Map Viewing Client\")\n return dict(map=map)","def get_map_locs(self, CalSwimView):\n # Initialize query list\n query_build = []\n \n if (CalSwimView.lat and CalSwimView.lng): \n # Search query has a specified location thus check against intersection of points and polygons in database\n self.cursor.execute(\"SET @center = GeomFromText('POINT(%s %s)');\",(float(CalSwimView.lat), float(CalSwimView.lng)))\n self.cursor.execute(\"SET @radius = %s;\",(CalSwimView.radius))\n self.cursor.execute(\"\"\"\n SET @bbox = CONCAT('POLYGON((',\n X(@center) - @radius, ' ', Y(@center) - @radius, ',',\n X(@center) + @radius, ' ', Y(@center) - @radius, ',',\n X(@center) + @radius, ' ', Y(@center) + @radius, ',',\n X(@center) - @radius, ' ', Y(@center) + @radius, ',',\n X(@center) - @radius, ' ', Y(@center) - @radius, '))'\n );\n \"\"\")\n query_build.append(\"\"\"\n SELECT gd_id, organization, project_name_short, project_name, project_description, data_type, data_target, AsText(location)\n FROM GeoData\n WHERE Intersects( location, GeomFromText(@bbox) )\n AND\n CASE geometrytype(location)\n WHEN 'POINT' THEN\n SQRT(POW( ABS( X(location) - X(@center)), 2) + POW( ABS(Y(location) - Y(@center)), 2 )) < @radius\n ELSE\n TRUE\n END\n \"\"\")\n # Search query has at least 1 keyword\n if len(CalSwimView.keywords) > 0:\n # Just a few MySQL notes:\n # Default MySQL operation executes an \"OR\" search among terms\n # To make sure all terms are in a given result, \"AND\" search among terms, then just add prefix \"+\" before each term\n # To exclude results with a given term, just add prefix \"-\" before the term\n keyword_query = \"*, \".join(CalSwimView.keywords) +\"*\" \n query_build.append(\"\"\" \n AND\n MATCH (organization, contact, project_name, project_description, project_funder, data_target, location_description, data_collector, data_type, keyword, other)\n AGAINST ('%(KeywordQuery)s' IN BOOLEAN MODE)\n \"\"\" % {\"KeywordQuery\":keyword_query})\n else:\n # Search query does not have a specified location\n query_build.append(\"\"\"\n SELECT gd_id, organization, project_name_short, project_name, project_description, data_type, data_target, AsText(location)\n FROM GeoData\n \"\"\")\n # Search query has at least 1 keyword\n if len(CalSwimView.keywords) > 0:\n # Just a few MySQL notes:\n # Default MySQL operation executes an \"OR\" search among terms\n # To make sure all terms are in a given result, \"AND\" search among terms, then just add prefix \"+\" before each term\n # To exclude results with a given term, just add prefix \"-\" before the term\n keyword_query = \"*, \".join(CalSwimView.keywords) +\"*\" \n query_build.append(\"\"\" \n WHERE\n MATCH (organization, contact, project_name, project_description, project_funder, data_target, location_description, data_collector, data_type, keyword, other)\n AGAINST ('%(KeywordQuery)s' IN BOOLEAN MODE)\n \"\"\" % {\"KeywordQuery\":keyword_query})\n select_query = \"\\n\".join(query_build)\n #print >> CalSwimView.errors, select_query\n \n # execute SQL query using execute() method.\n self.cursor.execute(select_query)\n\n # Fetch a single row using fetchone() method.\n rows = [] \n table_data = {}\n coordinates = []\n while(1):\n row=self.cursor.fetchone()\n if row == None:\n break \n coordinates.append( str(row[7]).replace('POINT(','').replace('POLYGON((','').replace(')','') )\n rows.append( {\"c\":[{\"v\":row[0]}, {\"v\":row[1]}, {\"v\":row[2]}, {\"v\":row[3]}, {\"v\":row[4]}, {\"v\":row[5]}, {\"v\":row[6]}]} )\n \n # Return search values as json\n cols = [{\"id\":'gd_id', \"label\":'gd_id', \"type\":'string'},\n {\"id\":'organization', \"label\":'Organization', \"type\":'string'},\n {\"id\":'project_short', \"label\":'Project Short', \"type\":'string'},\n {\"id\":'project', \"label\":'Project', \"type\":'string'},\n {\"id\":'description', \"label\":'Description', \"type\":'string'}, \n {\"id\":'target', \"label\":'Target', \"type\":'string'}]\n table_data[\"cols\"] = cols\n table_data[\"rows\"] = rows\n # Assign table data to json table data container\n json_data = {}\n json_data[\"table_data\"] = table_data\n json_data[\"coordinates\"] = coordinates\n \n # Close DB connections \n self.cursor.close()\n \n # Return results\n return json.dumps(json_data)","def test_google_bad_return(monkeypatch):\n RESULTS = {\n \"candidates\": [],\n \"status\": \"ZERO_RESULTS\"\n }\n\n class MockGet:\n def __init__(self, *args, **kwargs):\n pass\n\n def json(self):\n return RESULTS\n\n monkeypatch.setattr('requests.get', MockGet)\n script = GoogleMapApi()\n response = script.search_about_query(query='kjggdrr', g_key=1).json()\n assert response[\"status\"] != \"200 OK\"","def get(self, request):\n return Response(services.get_gsa_locations(request.query_params, request.META['HTTP_JWT']))","def get_map_josn(request):\n if request.method == 'GET':\n data = get_json()\n print('Responsed')\n return Response(data,status=status.HTTP_200_OK)","def results_gis_google(request, assessment_id):\n try:\n person = get_person(request)\n # try:\n # get the latest assessment from the city.\n if assessment_id:\n assessment = Assessment.objects.get(id=assessment_id)\n else:\n assessment = Assessment.objects.order_by('-date_started')[0]\n # except:\n # raise Exception('The City does not have any open assessment')\n template = loader.get_template(TEMPLATE_RESULTS_GIS_GOOGLE)\n\n context = RequestContext(request, {\n 'person': person,\n 'assessment': assessment,\n 'selected_main': \"RESULTS_GIS\",\n 'selected_detail': \"RESULTS_GIS_GOOGLE\",\n })\n return HttpResponse(template.render(context))\n except:\n if debug_is_on():\n raise\n else:\n return render_to_response(TEMPLATE_ERROR,\n {\"error_description\": sys.exc_info(), \"crpt_url\": CRPT_URL},\n context_instance=RequestContext(request))","def setUp(self):\n self.response = self.client.get('/map/')","def test_geocode(self):\n # get the minerva user's public folder\n params = {\n 'parentType': 'user',\n 'parentId': self._user['_id'],\n 'text': 'public'\n }\n response = self.request(\n path='/folder',\n method='GET',\n params=params,\n user=self._user\n )\n self.assertStatusOk(response)\n user_folder = response.json[0]\n\n with mock.patch.object(urllib, 'urlretrieve', download_data):\n # attempt to import as a regular user\n response = self.request(\n path='/geonames/setup',\n method='POST',\n params={\n 'folder': user_folder['_id']\n },\n user=self._user\n )\n self.assertStatus(response, 403)\n\n # import the database\n response = self.request(\n path='/geonames/setup',\n method='POST',\n params={\n 'folder': user_folder['_id']\n },\n user=self._admin\n )\n self.assertStatusOk(response)\n\n # set the geonames folder\n response = self.request(\n path='/system/setting',\n method='PUT',\n params={\n 'key': 'minerva.geonames_folder',\n 'value': user_folder['_id']\n },\n user=self._admin\n )\n self.assertStatusOk(response)\n\n # hit the geocoding endpoint\n response = self.request(\n path='/geonames/geocode',\n params={\n 'name': '\"little sheep mountain\"'\n },\n user=self._user\n )\n self.assertStatusOk(response)\n\n # check the response\n self.assertEqual(\n len(response.json['features']),\n 1\n )\n self.assertEqual(\n response.json['features'][0]['id'],\n 5428978 # geonameid\n )","def get_data(query):\n par = {\"key\": str(GOOGLE_KEY), \"query\": query}\n url = \"https://maps.googleapis.com/maps/api/place/textsearch/json\"\n req = requests.get(url, params=par)\n return req.json()","def placeToRoad(placeName):\n # sleep(2)\n g = gmaps.geocode(placeName)\n roadNo, roadName = '', ''\n zipCode, coor_Lat, coor_Lng = None, None, None\n if len(g) > 0:\n for ac in g[0]['address_components']:\n if ac['types'] and len(ac['types']) > 0:\n if ac['types'][0] == 'street_number':\n try:\n roadNo = ac['long_name']\n except:\n roadNo = ''\n if ac['types'][0] == 'route':\n try:\n roadName = ac['long_name']\n except:\n roadName = ''\n if ac['types'][0] == 'postal_code':\n try:\n zipCode = ac['long_name']\n except:\n zipCode = None\n\n # if 'long_name' in g[0]['address_components'][0].keys(): # road no.\n # if g[0]['address_components'][0]['types'][0] == 'street_number':\n # try:\n # roadNo = g[0]['address_components'][0]['long_name']\n # except:\n # roadNo = ''\n #\n # if 'long_name' in g[0]['address_components'][1].keys(): # road name\n # if g[0]['address_components'][1]['types'][0] == 'route':\n # try:\n # roadName = g[0]['address_components'][1]['long_name']\n # except:\n # roadName = ''\n #\n # if 'long_name' in g[0]['address_components'][-1].keys(): # zip code\n # if g[0]['address_components'][-1]['types'][0] == 'postal_code':\n # try:\n # zipCode = g[0]['address_components'][-1]['long_name']\n # except:\n # zipCode = None\n\n if 'location' in g[0]['geometry'].keys():\n try:\n coor = g[0]['geometry']['location'] # APPROXIMATE location\n coor_Lat = coor['lat']\n coor_Lng = coor['lng']\n except:\n coor_Lat, coor_Lng = None, None\n\n roadName = roadNo + ' ' + roadName\n coor = (coor_Lat, coor_Lng)\n return roadName, zipCode, coor","def api_call():\n\tresponse = requests.get(URL_API)\n\treturn response","def setup_platform(hass, config, add_devices, discovery_info=None):\n name = config.get(CONF_NAME)\n api_key = config.get(CONF_API_KEY)\n origin = config.get(CONF_ORIGIN)\n options = config.get(CONF_OPTIONS)\n display_zone = config.get(CONF_DISPLAY_ZONE)\n\n add_devices([GoogleGeocode(hass, origin, name, api_key, options, display_zone)])","def lookup_lat_lon(location_string):\n google_api_key = \"AIzaSyDAJxRxTE-ZC5M7qGN5Bg_FXwgc5e_TqdU\" \n \n\n base = \"https://maps.googleapis.com/maps/api/geocode/json?address=\"\n \n return base + location_string + \"&key=\" + google_api_key","def getting_location_key(latitude, longitude):\n\n API_Key = \"zIGuOeUd0aE4O621Gj1KGDc6JiZ3PAGb\"\n http_request = f\"http://dataservice.accuweather.com/locations/v1/cities/geoposition/search?apikey={API_Key}&q={latitude}%2C%20{longitude}&language=pt-br\"\n\n location_key_request = requests.get(http_request)\n\n if location_key_request.status_code != 200:\n print(\"It was not possible to retrive your location key. Please, try again later!!\")\n exit()\n\n else:\n location_key_response = location_key_request.json()\n\n location_key = location_key_response['Key']\n \n # EXTRACTING LOCATION INFORMATION --\n country = location_key_response['Country']['LocalizedName']\n state = location_key_response['AdministrativeArea']['ID']\n city = location_key_response['ParentCity']['LocalizedName']\n neighbourhood = location_key_response['LocalizedName']\n\n # PRINTING LOCATION INFORMATION --\n title_printer(\" ---- LOCATION ----\")\n time.sleep(0.5)\n\n print(\"Country\", end=\"\")\n print(f\"{country:.>73}\")\n time.sleep(0.5)\n\n print(\"State\", end=\"\")\n print(f\"{state:.>75}\")\n time.sleep(0.5)\n\n print(\"City\", end=\"\")\n print(f\"{city:.>76}\")\n time.sleep(0.5)\n\n print(\"Region\", end=\"\")\n print(f\"{neighbourhood:.>74}\")\n time.sleep(0.5)\n\n return location_key","def driving():\r\n name = request.args[\"address\"]\r\n end_name=request.args[\"end_point\"]\r\n end_lng = request.args[\"end_lng\"]\r\n end_lat = request.args[\"end_lat\"]\r\n end_lng = float(end_lng)\r\n end_lat = float(end_lat)\r\n start_lng=get_address(name)[1]\r\n start_lat=get_address(name)[0]\r\n\r\n\r\n #get coordinates of start and end point\r\n map_directions, geojson_str = get_driving_map(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n logging.warning(\"Map directions %s\", str(map_directions))\r\n\r\n\r\n #retrieve instructions\r\n instructions = get_driving_instructions(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n\r\n\r\n # generate interactive map\r\n return render_template(\r\n \"page4.html\",\r\n mapbox_token=MAPBOX_TOKEN,\r\n geojson_str=geojson_str,\r\n end_name=end_name,\r\n name=name,\r\n start_lng=start_lng,\r\n start_lat=start_lng,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n center_lng=(start_lng + end_lng) / 2,\r\n center_lat=(start_lat + end_lat) / 2,\r\n instructions=instructions,\r\n method = 'Driving'\r\n )","def getGeo(self):\n command = f'curl -s -m 5 http://ip-api.com/json/' + self.ip\n result = subprocess.run(command.split(), capture_output=True)\n data = result.stdout.decode(\"utf-8\").replace('\\n','')\n try:\n data = json.loads(data)\n except json.decoder.JSONDecodeError:\n # Error from ip-api.com\n data = None\n if data:\n # {\"status\":\"success\",\"country\":\"Yemen\",\"countryCode\":\"YE\",\"region\":\"SA\",\"regionName\":\"Amanat Alasimah\",\"city\":\"Sanaa\",\"zip\":\"\",\"lat\":15.3522,\"lon\":44.2095,\"timezone\":\"Asia/Aden\",\"isp\":\"Public Telecommunication Corporation\",\"org\":\"YemenNet\",\"as\":\"AS30873 Public Telecommunication Corporation\",\"query\":\"134.35.218.63\"}\n self.geodata = data\n else:\n self.geodata = None","def fetchGeoData():\n if request.method ==\"POST\":\n result = {}\n if request.get_json():\n post_requests = request.get_json()\n print(post_requests)\n result = db.getmapdata(post_requests['attr']) \n return result","def geocoding(address, API_KEY=API_KEY, GEOCODE_API_URL=GEOCODE_API_URL):\n # define the parameters of the search\n params = {\n 'address': '{}'.format(address),\n 'key': API_KEY\n }\n\n # Do the request and get the response data\n response = requests.get(GEOCODE_API_URL, params=params)\n response = response.json()\n\n geodata = parse_response(response)\n return geodata","def geoprocess(data, retry=None):\n host = settings.GEOP['host']\n port = settings.GEOP['port']\n\n geop_url = 'http://{}:{}/run'.format(host, port)\n\n try:\n response = requests.post(geop_url,\n data=json.dumps(data),\n headers={'Content-Type': 'application/json'})\n except ConnectionError as exc:\n if retry is not None:\n retry(exc=exc)\n\n if response.ok:\n return response.json()['result']\n else:\n raise Exception('Geoprocessing Error.\\n'\n 'Details: {}'.format(response.text))","def request_directions(start_location, end_location):\n now = datetime.datetime.now()\n directions_response = GMAPS.directions(start_location, end_location,\n mode=\"walking\", departure_time=now)\n parsed_directions_response = parse_directions_response(directions_response)\n return parsed_directions_response","def test_list_maps(self):\n res = self.client.get('/list_maps', follow_redirects=True)\n self.assertEqual(res.status_code, 200)\n\n self._create_map_sc()\n\n \"\"\"Testing with one map saved into database\"\"\"\n res = self.client.get('/list_maps', follow_redirects=True)\n self.assertEqual(res.status_code, 200)","def _check_api_key(self):\n try:\n self.maps.places_nearby(\n location=(53.909804, 27.580184),\n radius=650,\n open_now=False,\n language=config.LANGUAGE,\n type='cafe',\n # rank_by='distance', # IMPORTANT: cannot use rank_by and radius options together\n page_token=None,\n )\n except Exception as e:\n\n with self.__writelock:\n self.print(f'ERROR: bad API key \"{self.maps.key}\" (tracker={self.stats.previous_requests})\\n')\n raise e","def get(self):\n street = self.request.args.get(\"street\", \"\")\n zip = self.request.args.get(\"zip\",\"\")\n city = self.request.args.get(\"city\",\"\")\n country = self.request.args.get(\"country\",\"Germany\")\n\n if street==\"\" or city==\"\" or country==\"\":\n return {'success': False, \n 'msg': self._(\"no full address was given\")\n }\n try:\n lat, lng = self.retrieve_location(street, zip, city, country)\n except LocationNotFound:\n return {'success': False, \n 'msg': self._(\"we couldn't lookup a geo coordinates for this address\")\n }\n return {\n 'success' : True,\n 'lat' : lat,\n 'lng' : lng\n }","def draw_map(self):\n\n polygon_lats, polygon_longs = self.get_polygon_coordinates()\n car_route = self.get_car_route()\n\n polygon = self.construct_polygon(polygon_lats, polygon_longs)\n\n map_path = f'{self.result_path}/map_{self.postfix}.html'\n\n self.plot_map(df=car_route,\n polygon=polygon,\n lat_col='lat',\n lon_col='long',\n plot_points=True,\n plot_polygon=True,\n plot_heatmap=True,\n file_name=map_path)","def post(self):\n data = json.dumps(request.get_json())\n houseNumber = json.loads(data)['HouseNumber']\n street = json.loads(data)['Street']\n city = json.loads(data)['city']\n #address = '&housenumber='+houseNumber+'&street='+street+'&city='+city\n response = hereService.getLatLang(houseNumber, street, city)\n return response","def visualize(g):\n url = \"http://www.gcmap.com/mapui?P=\"\n routes = []\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n route = (g.city_dict[key].get_code(), flight[0])\n if(route not in routes):\n routes.append(route)\n \n for flight in routes:\n url = url + flight[0] + \"-\" + flight[1]\n url = url + \",+\"\n \n url = url[:-2]\n return url","def call(self):\n\n self.url = self._prepare_url()\n status_code, response = self._do_request(self.url)\n return self._process_response(status_code, response)","def async_set_geocoding(provider, tracking_id=None, event_id=None):\n loop = asyncio.get_event_loop()\n loop.run_in","def _sendRequest(lat, lng):\n r = requests.get(\n 'https://api.forecast.io/forecast/' +\n _forecastApiKey +\n '/' + lat +\n ',' + lng +\n '?units=us'\n )\n\n data = r.json()\n return data","def test_map_details(self):\n\t\tcreate_cartography()\n\t\tmap = Map.objects.get(id=1)\n\t\tc = Client()\n\t\tresponse = c.get(\"/maps/%s\" % str(map.id))\n\t\tself.assertEquals(response.status_code, 200)","async def google(self, ctx, *, query: str=None):\n # Handle no query being provided\n if query is None:\n return await ctx.error('Please provide a query!')\n\n # 'google_embed' is dependent on a test that checks whether google has embedded any external data on the page\n # 'result_nums' is the no. of results to display when there is no embedded data\n google_embed = False\n params = {'q': quote_plus(query), 'source': 'hp'}\n results_num = 3\n\n # Tries its best to imitate a real browser visit, an old user-agent is used to make scraping easier\n async with self.aiohttp_session.get(self.url, params=params, headers=self.headers) as r:\n html = await r.text()\n\n # Beautiful soup\n soup = BeautifulSoup(html, 'lxml')\n\n # Get links and their brief descriptions, only upto 4 are taken at a time, it should've been three, but\n # if you read the code, it tries to work around an extra entry that is just 'Images for '.\n # URLs on google search are redirected through 'google.com/url?url=xxxxx' , this uses cgi and urlparse to\n # grab only the 'url' URL parameter and get rid of the other parameters google passes for logging etc to\n # 'google.com/url'\n result_links = [parse_qs(urlparse(x.attrs['href'])[4])['url'][0] for x in soup.select('div.g h3.r a')[:4] if\n '/search' not in x.attrs['href'] and not x.text == '']\n result_desc = [x.text for x in soup.select('div#ires div.g div.s span.st')[:4] if\n '/search' not in x.text and not x.text == '']\n\n # 'hp-xpdbox' is the class for google's embedded data, if this exists, google_embed is changed to True\n # and results are changed to 2\n if soup.select('div.hp-xpdbox div._tXc'):\n google_embed = True\n embed_title = [a.text for a in soup.select('div._B5d')][0]\n try:\n embed_type = [a.text for a in soup.select('div._Pxg')][0]\n except IndexError:\n embed_type = None\n embed_details = [a.text for a in soup.select('div._tXc span')][0]\n results_num -= 1\n\n # Embedded data might not always have an image, this works around that\n img = None\n try:\n img = [img.attrs.get('src') for img in soup.select('div._i8d img')][0]\n except IndexError:\n pass\n\n # Create embed if google_embed is true\n if google_embed:\n msg = f\"**{embed_title}**\"\n if embed_type is not None:\n msg += f\" ({embed_type})\"\n msg += f\"\\n\\n{embed_details}\\n\"\n if img:\n msg += f\"**Image:**\\n{img}\"\n\n results = \"\\n\\n\".join([f'<{link}>\\n{desc}' for link, desc in list(zip(result_links, result_desc))[:results_num]])\n\n if google_embed:\n await ctx.message.edit(content=f\"**Results for {query}:**\\n{results}\\n\\n{msg}\")\n else:\n await ctx.message.edit(content=f\"**Results for {query}:**\\n{results}\")","def GetLocation(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def Greenland_map(service='ESRI_Imagery_World_2D', epsg=3413, xpixels=5000):\n m = Basemap(projection='npstere', boundinglat=70, lon_0=315, epsg=epsg, llcrnrlon=300, llcrnrlat=57, urcrnrlon=20, urcrnrlat=80, resolution='h')\n \n plt.figure()\n m.arcgisimage(service=service, xpixels=xpixels)\n plt.show()\n return m","def reverse_geocoding(lat, lng, API_KEY=API_KEY, GEOCODE_API_URL=GEOCODE_API_URL):\n params = {\n 'latlng': '{},{}'.format(lat, lng),\n 'key': API_KEY\n }\n\n # Do the request and get the response data\n response = requests.get(GEOCODE_API_URL, params=params)\n response = response.json()\n geodata = parse_response(response)\n return geodata","def build_maps():\n return render_template(\"maps.html\")","def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\n width, height = 256 * wTileN, 256 * hTileN\n map_img = Image.new('RGB', (width, height))\n for x in range(0, wTileN):\n for y in range(0, hTileN):\n url = 'https://mt0.google.com/vt?x=' + \\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\n current_tile = str(x)+'-'+str(y)\n urllib.request.urlretrieve(url, current_tile)\n map_img.paste(Image.open(current_tile), (x*256, y*256))\n os.remove(current_tile)\n return map_img","def run(self):\n while not self.setup() and self.running:\n pass\n\n while self.running:\n # Create a byte array to receive the computed maps\n mapb = bytearray(self.MAP_SIZE_PIXELS * self.MAP_SIZE_PIXELS)\n\n # Get final map \n self.slam.getmap(mapb)\n try:\n self.connection.send(mapb)\n except socket.error:\n print \"MapServer: Client disconnected\"\n if self.running:\n self.setup()","def makeAddressToGeocodeRequest(address):\n global headersGlobal, URL_addressToGeocode # get global variables\n\n key = variables.bingMapsAPIKey # api key\n\n # construct the url\n url = URL_addressToGeocode + str(address[0]) + \"/\" + str(address[1]) + \"/\" + str(address[2]) + \"/\" + str(\n address[3]) + \"/\" + str(address[4]) + \"?key=\" + key\n\n request = requests.get(url, headers=headersGlobal) # make the request\n return request # return the request","def main():\n\n creds = None\n # The file token.json stores the user's access and refresh tokens, and is\n # created automatically when the authorization flow completes for the first\n # time.\n\n # There was no need to do this with Google Sheets... I just felt like being extra.\n if os.path.exists('token.json'):\n creds = Credentials.from_authorized_user_file('token.json', SCOPES)\n # If there are no (valid) credentials available, let the user log in.\n if not creds or not creds.valid:\n if creds and creds.expired and creds.refresh_token:\n creds.refresh(Request())\n else:\n flow = InstalledAppFlow.from_client_secrets_file(\n 'credentials.json', SCOPES)\n creds = flow.run_local_server(port=0)\n # Save the credentials for the next run\n with open('token.json', 'w') as token:\n token.write(creds.to_json())\n\n service = build('sheets', 'v4', credentials=creds)\n\n # Call the Sheets API\n sheet = service.spreadsheets()\n map_df = pd.read_csv('data/rel_map.csv')\n \n for i, rows in map_df.iterrows():\n print(rows.show_season, rows.lead)\n first_url = rows.show_season\n write_from_URL(wiki_head + first_url, sheet, rows.lead, rows.show_season)","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # google_maps_destination\n # google_maps_origin\n # Message Destinations:\n # fn_google_maps_directions\n # Functions:\n # fn_google_maps_directions\n # Workflows:\n # example_google_maps_directions\n # Rules:\n # Get Directions\n\n\n yield ImportDefinition(u\"\"\"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\nLCAiZXhwb3J0X2RhdGUiOiAxNTM5ODY3NjgwMjk5fQ==\n\"\"\"\n )","def runAnalytics():\n #gets OAuth from the API\n analytics = get_Analytics_service()\n #get the object return from the API\n #send that object to print out useful fields\n response = get_report(analytics)\n print_response(response)","def main():\n ip_obj = get_ip()\n url = (\"http://ipvigilante.com/\" + ip_obj.ip_address + \"/full\")\n response = urlopen(url)\n data_json = response.read().decode(\"utf-8\")\n geoloc = json.loads(data_json)\n\n # print(geoloc)\n print(\"ipv4: \", geoloc['data']['ipv4'])\n print(\"hostname: \", geoloc['data']['hostname'])\n print(\"continent_code: \", geoloc['data']['continent_code'])\n print(\"continent_name: \", geoloc['data']['continent_name'])\n print(\"country_iso_code: \", geoloc['data']['country_iso_code'])\n print(\"country_name: \", geoloc['data']['country_name'])\n print(\"subdivision_1_iso_code: \", geoloc['data']['subdivision_1_iso_code'])\n print(\"subdivision_1_name: \", geoloc['data']['subdivision_1_name'])\n print(\"subdivision_2_iso_code: \", geoloc['data']['subdivision_2_iso_code'])\n print(\"subdivision_2_name: \", geoloc['data']['subdivision_2_name'])\n print(\"city_name: \", geoloc['data']['city_name'])\n print(\"metro_code: \", geoloc['data']['metro_code'])\n print(\"time_zone: \", geoloc['data']['time_zone'])\n print(\"postal_code: \", geoloc['data']['postal_code'])\n print(\"latitude: \", geoloc['data']['latitude'])\n print(\"longitude: \", geoloc['data']['longitude'])\n print(\"accuracy_radius: \", geoloc['data']['accuracy_radius'])","def geocube():","def __init__(self, lat, lon, grid, api):\n self.lat = lat\n self.lon = lon\n self.city = grid['city']\n self.county = grid['county']\n self.village = grid['village']\n self.api = api\n self.result = {}","def setUp(self):\n SetUp.setUp()\n self.response = self.client.get('/map/')","def google(self, input):\n\n args = input.args or \"\"\n parser = self.OptionParser()\n parser.add_option(\"-d\", \"-r\", \"--results\", dest=\"results\", default=1, type=\"int\")\n (options, args) = parser.parse_args(args.split())\n if not args:\n raise self.BadInputError()\n query = \" \".join(args).encode('utf-8')\n\n if options.results < 1:\n options.results = 1\n elif options.results > 10:\n options.results = 10\n\n try:\n data = urllib.urlopen('http://www.google.com/uds/GwebSearch?callback=GwebSearch.RawCompletion&context=0&lstkp=0&hl=en&key=ABQIAAAAeBvxXUmueP_8_kTINo0H4hSKL4HoBFFxfS_vfvgFpLqAt5GPWRTHDAESci2RYvZRkcpsYXapXjZWKA&v=1.0&rsz=large&q=%s' % urllib.quote(query)).read()\n except IOError: \n self.say(\"Error: Unable to establish a connection to google.com\")\n return\n data = unescapeuni(data)\n data = decodehtml(data)\n\n m = re.search('estimatedResultCount\":\"([^\"]+)\"', data)\n if m:\n matches = m.group(1)\n m = re.findall(r'\"url\":\"([^\"]*)\".*?\"titleNoFormatting\":\"([^\"]*)\",\"content\":\"([^\"]*)\"', data, re.IGNORECASE)\n if m:\n if len(m) < options.results:\n options.results = len(m)\n if options.results == 1:\n self.say('\\x02%s\\x02 - ( \\x1f%s\\x1f ) [%s matches]' % (removehtml(m[0][1]), urllib.unquote(m[0][0]), matches))\n self.say(removehtml(m[0][2]))\n else:\n self.say('Showing the first \\x02%s\\x02 of \\x02%s\\x02 matches' % (options.results, matches))\n for x in range(options.results):\n self.say('\\x02%s\\x02 - ( \\x1f%s\\x1f )' % (removehtml(m[x][1]), urllib.unquote(m[x][0])))\n\n else:\n self.say('Your search for \\x02%s\\x02 did not return any results.' % input.args)","def do_gga_location(self,data):\n global location\n\n d = data.split(',')\n location['type'] = 'GGA'\n location['lat'] = \"%s%s\" % (d[1],d[2])\n location['long'] = \"%s%s\" % (d[3],d[4])\n location['alt'] = \"%s %s\" % (d[8],d[9])\n location['time'] = self.format_time(d[0])\n location['sats'] = d[7]","def __init__(self, api_key=None, secret_key=None, headers=None):\n # set up base requester\n self._base_requester = Requester(API_ENDPOINT, api_key=api_key, secret_key=secret_key, headers=headers)\n # add each endpoint\n self.geocode = self.Geocode(self._base_requester)\n self.places = self.Places(self._base_requester)","def _onbuttonReqMapClicked(self):\n\n day1=str(self.combo_wms_time_first_d.currentText())\n hour1=str(self.combo_wms_time_first_h.currentText())\n date_val=day1+hour1\n depth=str(self.combo_wms_layer_depth.currentText())\n variable=str(self.combo_variable_list.currentText())\n product=str(self.combo_product_list.currentText())\n dataset=str(self.combo_dataset_list.currentText())\n xmin=int(float(self.WMS_westBound.text()))\n xmax=int(float(self.WMS_eastBound.text()))\n ymin=int(float(self.WMS_southBound.text()))\n ymax=int(float(self.WMS_northBound.text()))\n dir_out=self.tmp\n rastermin=self.minscale_value.text()\n rastermax=self.maxscale_value.text()\n nb_colors=self.nbcolors_value.text()\n xpixels=float(self.Xpixels_value.text())\n xparallels=int(self.Xparallels_value.text())\n ymeridians=int(self.Ymedians_value.text())\n dpi=300\n colorbar=str(self.combo_colorbar.currentText())\n input_srs=str(self.combo_proj.currentText())\n epsg_val=input_srs.split(':')[1]\n ll_polar=False\n##\tif self.checkBox_2.isChecked() == True :\n##\t print \"Projection arctic\"\n## #m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\n## # urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \n## ##m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \n## m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \n## #Proj4js.defs[\"EPSG:3408\"] = \"+proj=laea +lat_0=90 +lon_0=0 +x_0=0 +y_0=0 +a=6371228 +b=6371228 +units=m +no_defs\";\n## #\n## ll_polar=True\n##\telif self.checkBox_3.isChecked() == True :\n##\t print \"Projection antarctic\"\n## m = Basemap(projection='spstere',boundinglat=ymax,lon_0=180,round=True,resolution='l') \n## ll_polar=True\n##\telse : \n m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\n urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \n print \"cylindric projection\"\n\n # ypixels not given, find by scaling xpixels by the map aspect ratio.\n ypixels = int(m.aspect*xpixels)\n style='boxfill/'+colorbar\n print input_srs\n print epsg_val\n p = pyproj.Proj(init=\"epsg:%s\" % epsg_val, preserve_units=True)\n xmin,ymin = p(m.llcrnrlon,m.llcrnrlat)\n xmax,ymax = p(m.urcrnrlon,m.urcrnrlat)\n if epsg_val == '4326' :\n xmin = (180./np.pi)*xmin; xmax = (180./np.pi)*xmax\n ymin = (180./np.pi)*ymin; ymax = (180./np.pi)*ymax\n print \"Cylindric projection\"\n print xmin,xmax,ymin,ymax\n print style\n img = self.wms.getmap(layers=[variable],service='wms',bbox=(xmin,ymin,xmax,ymax),\n size=(int(xpixels),ypixels),\n format='image/png',\n elevation=depth,\n srs=input_srs,\n time=date_val,\n colorscalerange=rastermin+','+rastermax,numcolorbands=nb_colors,logscale=False,\n styles=[style])\n image=imread(io.BytesIO(img.read()),format='png')\n if variable == \"sea_water_velocity\" :\n ylabel=\"magnitude\"\n else :\n ylabel=self.wms[variable].abstract\n\n long_name=self.wms[variable].title\n title=product+\" - \"+long_name+\" \"+\" - \"+date_val\n file_pal='./palettes/thredds/'+colorbar+'.pal'\n my_cmap=compute_cmap(file_pal,colorbar)\n cm.register_cmap(name=colorbar, cmap=my_cmap)\n font=10\n norm = mpl.colors.Normalize(vmin=float(rastermin), vmax=float(rastermax), clip=False) \n parallels=np.round(np.arange(ymin,ymax+xparallels/2,xparallels))\n meridians = np.round(np.arange(xmin,xmax+ymeridians/2,ymeridians))\n # Plot figure \n plt.figure(figsize=(20,12))\n if epsg_val == '4326' :\n m.drawcoastlines(color='lightgrey',linewidth=0.25)\n m.fillcontinents(color='lightgrey')\n m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\n\n elif ll_polar == True : \n #m.drawcoastlines(linewidth=0.5)\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\n m.drawmeridians(meridians[:-1],labels=[1,1,1,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\n ## Plot the image\n cs=m.imshow(image,origin='upper',alpha=1,cmap=(cm.get_cmap(colorbar,int(nb_colors))),norm=norm)\n ## Add colorbar\n cb=plt.colorbar(cs,orientation='vertical',format='%4.2f',shrink=0.7)\n cb.ax.set_ylabel(ylabel, fontsize=int(font)+4)\n cl=plt.getp(cb.ax, 'ymajorticklabels')\n plt.setp(cl, fontsize=font)\n\n plt.title(title,fontsize=font+4,y=1.05)\n plt.savefig('images/'+product+\"_\"+long_name+\"_\"+date_val+\"_basemap.png\",dpi=300,bbox_inches='tight')\n plt.show()","def google(query, num_results=1):\n\tif not API_KEY:\n\t\traise ConfigException(\"Require API_KEY for googleapi. Reload after setting.\")\n\td = { \"q\" : query.encode(\"utf-8\"), \"key\" : API_KEY, \"cx\" : CSE_ID, \"num\" : num_results,\n\t\t\"fields\" : \"spelling/correctedQuery,items(title,link,snippet)\" }\n\t\n\tf = urlopen(SEARCH_URL % (urlencode(d)))\n\tgdata = load(f)\n\tif f.getcode() == 200:\n\t\tresults = []\n\t\tspelling = gdata.get(\"spelling\")\n\t\tif spelling: spelling = spelling[\"correctedQuery\"]\n\t\tif \"items\" in gdata:\n\t\t\tfor item in gdata[\"items\"]:\n\t\t\t\tsnippet = item[\"snippet\"].replace(\" \\n\", \" \") if \"snippet\" in item else \"\"\n\t\t\t\tresults.append((item[\"title\"], snippet, item[\"link\"]))\n\t\treturn (spelling, results)\n\telse:\n\t\traise RuntimeError(\"Error: %s\" % (gdata.replace(\"\\n\", \" \")))"],"string":"[\n \"def google_map_api(request):\\n\\treturn {\\n\\t\\t'GOOGLE_MAPS_API' : settings.GOOGLE_MAPS_API,\\n\\t}\",\n \"def googlemaps(request):\\n assert False\\n # return {\\\"GOOGLEMAPS_API_KEY\\\": settings.GOOGLEMAPS_API_KEY}\",\n \"def google(self):\\r\\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\\r\\n middle = '&zoom=14&size=400x400&markers='\\r\\n suffix = '&key=AIzaSyD5nqmDGFH1SUZxJAYVtFHP7RNjjFE9CHg'\\r\\n marker = '+'.join(self.placeToSearch) # marker in google format, no space but + separator\\r\\n request = prefix + marker+middle+marker+suffix\\r\\n\\r\\n return request\",\n \"async def google(self, query):\\r\\n g_api = \\\"http://maps.googleapis.com/maps/api/geocode/json?\\\"\\r\\n url = g_api + urllib.parse.urlencode({'address': query})\\r\\n json_data = requests.get(url).json()\\r\\n formatted_address=json_data['results'][0]['formatted_address']\\r\\n sat1=json_data['results'][0]['geometry']['location']['lat']\\r\\n sat2 = json_data['results'][0]['geometry']['location']['lng']\\r\\n info = discord.Embed(title=query, color=0xefefef)\\r\\n info.add_field(name=\\\"\\\\u200b\\\", value=formatted_address, inline=False)\\r\\n info.add_field(name=\\\"\\\\u200b\\\", value=\\\"Lat:\\\"+str(sat1), inline=False)\\r\\n info.add_field(name=\\\"\\\\u200b\\\", value=\\\"Lng:\\\"+str(sat2), inline=False)\\r\\n await self.bot.say(embed=info)\",\n \"def google_maps(request):\\n gmaps_api_key = getattr(settings, 'GOOGLE_MAPS_API', False)\\n return {\\n 'GOOGLE_MAPS_API': gmaps_api_key,\\n 'google_maps': gmaps_api_key\\n }\",\n \"def callGoogle(endpoint: str, params: dict) -> str:\\n # hit API \\n call = requests.get(endpoint, params=params)\\n response = call.json()\\n # grab first element in payload\\n result: dict = response['results'][0]\\n # format lat and lng to a string\\n return f\\\"{result['geometry']['location']['lat']},{result['geometry']['location']['lng']}\\\"\",\n \"def api_call(travel_info):\\n gmap = googlemaps.Client(key='your-google-maps-api-key')\\n\\n now = datetime.now()\\n try:\\n directions_result = gmap.directions(\\n travel_info['start_address'],\\n travel_info['end_address'],\\n mode=travel_info['travel_mode'],\\n departure_time=now\\n )\\n except googlemaps.exceptions.ApiError:\\n print('An Error occurred while retrieving directions')\\n\\n if 'directions_result' in locals() and len(directions_result):\\n directions_result = json.dumps(directions_result)\\n return json.loads(directions_result)[0]\\n else:\\n return False\",\n \"def gmaps_rest(query, mode=\\\"place\\\"):\\n # https://www.google.com/maps/embed/v1/MODE?key=YOUR_API_KEY¶meters\\n base_url = \\\"https://www.google.com/maps/embed/v1\\\"\\n key = f\\\"key={_gmaps_key}\\\"\\n q_dict = {\\\"q\\\": query, \\\"zoom\\\": \\\"7\\\"}\\n # q = query_encode(urllib.parse.urlencode(q_dict))\\n q = urllib.parse.urlencode(q_dict).replace(\\\"%2C+\\\", \\\",\\\")\\n url = f\\\"{base_url}/{mode}?{key}&{q}\\\"\\n return url\",\n \"def generate_googlemaps(self):\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url\\n args['copyright'] = self.options.copyright\\n\\n s = r\\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:v=\\\"urn:schemas-microsoft-com:vml\\\">\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv=\\\"content-type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>\\n <script>\\n //<![CDATA[\\n\\n /*\\n * Constants for given map\\n * TODO: read it from tilemapresource.xml\\n */\\n\\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n var opacity = 0.75;\\n var map;\\n var hybridOverlay;\\n\\n /*\\n * Create a Custom Opacity GControl\\n * http://www.maptiler.org/google-maps-overlay-opacity-control/\\n */\\n\\n var CTransparencyLENGTH = 58;\\n // maximum width that the knob can move (slide width minus knob width)\\n\\n function CTransparencyControl( overlay ) {\\n this.overlay = overlay;\\n this.opacity = overlay.getTileLayer().getOpacity();\\n }\\n CTransparencyControl.prototype = new GControl();\\n\\n // This function positions the slider to match the specified opacity\\n CTransparencyControl.prototype.setSlider = function(pos) {\\n var left = Math.round((CTransparencyLENGTH*pos));\\n this.slide.left = left;\\n this.knob.style.left = left+\\\"px\\\";\\n this.knob.style.top = \\\"0px\\\";\\n }\\n\\n // This function reads the slider and sets the overlay opacity level\\n CTransparencyControl.prototype.setOpacity = function() {\\n // set the global variable\\n opacity = this.slide.left/CTransparencyLENGTH;\\n this.map.clearOverlays();\\n this.map.addOverlay(this.overlay, { zPriority: 0 });\\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\\n this.map.addOverlay(hybridOverlay);\\n }\\n }\\n\\n // This gets called by the API when addControl(new CTransparencyControl())\\n CTransparencyControl.prototype.initialize = function(map) {\\n var that=this;\\n this.map = map;\\n\\n // Is this MSIE, if so we need to use AlphaImageLoader\\n var agent = navigator.userAgent.toLowerCase();\\n if ((agent.indexOf(\\\"msie\\\") > -1) && (agent.indexOf(\\\"opera\\\") < 1)){this.ie = true} else {this.ie = false}\\n\\n // create the background graphic as a <div> containing an image\\n var container = document.createElement(\\\"div\\\");\\n container.style.width=\\\"70px\\\";\\n container.style.height=\\\"21px\\\";\\n\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\\\";\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; ' +loader+ '\\\" ></div>';\\n } else {\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)\\\" ></div>';\\n }\\n\\n // create the knob as a GDraggableObject\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\\\";\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.overflow=\\\"hidden\\\";\\n this.knob_img = document.createElement(\\\"div\\\");\\n this.knob_img.style.height=\\\"21px\\\";\\n this.knob_img.style.width=\\\"83px\\\";\\n this.knob_img.style.filter=loader;\\n this.knob_img.style.position=\\\"relative\\\";\\n this.knob_img.style.left=\\\"-70px\\\";\\n this.knob.appendChild(this.knob_img);\\n } else {\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.backgroundImage=\\\"url(http://www.maptiler.org/img/opacity-slider.png)\\\";\\n this.knob.style.backgroundPosition=\\\"-70px 0px\\\";\\n }\\n container.appendChild(this.knob);\\n this.slide=new GDraggableObject(this.knob, {container:container});\\n this.slide.setDraggableCursor('pointer');\\n this.slide.setDraggingCursor('pointer');\\n this.container = container;\\n\\n // attach the control to the map\\n map.getContainer().appendChild(container);\\n\\n // init slider\\n this.setSlider(this.opacity);\\n\\n // Listen for the slider being moved and set the opacity\\n GEvent.addListener(this.slide, \\\"dragend\\\", function() {that.setOpacity()});\\n //GEvent.addListener(this.container, \\\"click\\\", function( x, y ) { alert(x, y) });\\n\\n return container;\\n }\\n\\n // Set the default position for the control\\n CTransparencyControl.prototype.getDefaultPosition = function() {\\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\\n }\\n\\n /*\\n * Full-screen Window Resize\\n */\\n\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n // map.checkResize();\\n }\\n\\n\\n /*\\n * Main load function:\\n */\\n\\n function load() {\\n\\n if (GBrowserIsCompatible()) {\\n\\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\\n var gcr = GMapType.prototype.getCopyrights;\\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\\n return [\\\"%(copyright)s\\\"].concat(gcr.call(this,bounds,zoom));\\n }\\n\\n map = new GMap2( document.getElementById(\\\"map\\\"), { backgroundColor: '#fff' } );\\n\\n map.addMapType(G_PHYSICAL_MAP);\\n map.setMapType(G_PHYSICAL_MAP);\\n\\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\\n\\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\\n GEvent.addListener(map, \\\"maptypechanged\\\", function() {\\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\\n map.addOverlay(hybridOverlay);\\n } else {\\n map.removeOverlay(hybridOverlay);\\n }\\n } );\\n\\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\\n var mercator = new GMercatorProjection(mapMaxZoom+1);\\n tilelayer.getTileUrl = function(tile,zoom) {\\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\\n return \\\"http://www.maptiler.org/img/none.png\\\";\\n }\\n var ymax = 1 << zoom;\\n var y = ymax - tile.y -1;\\n var tileBounds = new GLatLngBounds(\\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\\n );\\n if (mapBounds.intersects(tileBounds)) {\\n return zoom+\\\"/\\\"+tile.x+\\\"/\\\"+y+\\\".png\\\";\\n } else {\\n return \\\"http://www.maptiler.org/img/none.png\\\";\\n }\\n }\\n // IE 7-: support for PNG alpha channel\\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\\n tilelayer.isPng = function() { return true;};\\n tilelayer.getOpacity = function() { return opacity; }\\n\\n overlay = new GTileLayerOverlay( tilelayer );\\n map.addOverlay(overlay);\\n\\n map.addControl(new GLargeMapControl());\\n map.addControl(new GHierarchicalMapTypeControl());\\n map.addControl(new CTransparencyControl( overlay ));\\n \\\"\\\"\\\" % args # noqa\\n if self.kml:\\n s += \\\"\\\"\\\"\\n map.addMapType(G_SATELLITE_3D_MAP);\\n map.getEarthInstance(getEarthInstanceCB);\\n \\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n\\n map.enableContinuousZoom();\\n map.enableScrollWheelZoom();\\n\\n map.setMapType(G_HYBRID_MAP);\\n }\\n resize();\\n }\\n \\\"\\\"\\\"\\n if self.kml:\\n s += \\\"\\\"\\\"\\n function getEarthInstanceCB(object) {\\n var ge = object;\\n\\n if (ge) {\\n var url = document.location.toString();\\n url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\\n var link = ge.createLink(\\\"\\\");\\n if (\\\"%(publishurl)s\\\") { link.setHref(\\\"%(publishurl)s/doc.kml\\\") }\\n else { link.setHref(url) };\\n var networkLink = ge.createNetworkLink(\\\"\\\");\\n networkLink.setName(\\\"TMS Map Overlay\\\");\\n networkLink.setFlyToView(true);\\n networkLink.setLink(link);\\n ge.getFeatures().appendChild(networkLink);\\n } else {\\n // alert(\\\"You should open a KML in Google Earth\\\");\\n // add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n s += \\\"\\\"\\\"\\n onresize=function(){ resize(); };\\n\\n //]]>\\n </script>\\n </head>\\n <body onload=\\\"load()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n </body>\\n </html>\\n \\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def request_map():\\n\\n rospy.loginfo(\\\"Requesting the map\\\")\\n rospy.wait_for_service('dynamic_map')\\n getMap = rospy.ServiceProxy('dynamic_map', GetMap)\\n g = getMap().map\\n\\n return g\",\n \"def test_api_googlemaps(monkeypatch):\\n\\n def mock_geocode(*args, **kwargs):\\n \\\"\\\"\\\"Tips:\\n mock_geocode must take as many arguments as the called function\\n \\\"\\\"\\\"\\n\\n return {\\n \\\"latitude\\\": 48.856614,\\n \\\"longitude\\\": 2.3522219,\\n \\\"address\\\": \\\"Paris, France\\\"\\n }\\n\\n monkeypatch.setattr(\\n GoogleMapsApi, 'geocode', mock_geocode)\\n from config import GMAPS_KEY\\n gmaps_key = GMAPS_KEY\\n api = GoogleMapsApi(gmaps_key)\\n api_result = api.geocode(\\\"Paris\\\")\\n\\n assert api_result[\\\"address\\\"] == \\\"Paris, France\\\"\\n assert api_result[\\\"latitude\\\"] == 48.856614\\n assert api_result[\\\"longitude\\\"] == 2.3522219\",\n \"def test_query_google(self):\\n google_api = LocationData()\\n latLng = google_api.getLatLong(test_address)\\n self.assertEqual(latLng['lat'], 32.625849)\",\n \"def generate_googlemaps(self):\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = format_extension[self.image_output.format]\\n args['publishurl'] = \\\"\\\" if self.options.url is None else self.options.url\\n args['copyright'] = self.options.copyright\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:v=\\\"urn:schemas-microsoft-com:vml\\\">\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv=\\\"content-type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\\n <script type=\\\"text/javascript\\\">\\n //<![CDATA[\\n\\n /*\\n * Constants for given map\\n * TODO: read it from tilemapresource.xml\\n */\\n\\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n var opacity = 0.75;\\n var map;\\n var ge;\\n var hybridOverlay;\\n\\n /*\\n * Create a Custom Opacity GControl\\n * https://github.com/mj10777/mapmbtilesgoogle-maps-overlay-opacity-control/\\n */\\n\\n var CTransparencyLENGTH = 58;\\n // maximum width that the knob can move (slide width minus knob width)\\n\\n function CTransparencyControl( overlay ) {\\n this.overlay = overlay;\\n this.opacity = overlay.getTileLayer().getOpacity();\\n }\\n CTransparencyControl.prototype = new GControl();\\n\\n // This function positions the slider to match the specified opacity\\n CTransparencyControl.prototype.setSlider = function(pos) {\\n var left = Math.round((CTransparencyLENGTH*pos));\\n this.slide.left = left;\\n this.knob.style.left = left+\\\"px\\\";\\n this.knob.style.top = \\\"0px\\\";\\n }\\n\\n // This function reads the slider and sets the overlay opacity level\\n CTransparencyControl.prototype.setOpacity = function() {\\n // set the global variable\\n opacity = this.slide.left/CTransparencyLENGTH;\\n this.map.clearOverlays();\\n this.map.addOverlay(this.overlay, { zPriority: 0 });\\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\\n this.map.addOverlay(hybridOverlay);\\n }\\n }\\n\\n // This gets called by the API when addControl(new CTransparencyControl())\\n CTransparencyControl.prototype.initialize = function(map) {\\n var that=this;\\n this.map = map;\\n\\n // Is this MSIE, if so we need to use AlphaImageLoader\\n var agent = navigator.userAgent.toLowerCase();\\n if ((agent.indexOf(\\\"msie\\\") > -1) && (agent.indexOf(\\\"opera\\\") < 1)){this.ie = true} else {this.ie = false}\\n\\n // create the background graphic as a <div> containing an image\\n var container = document.createElement(\\\"div\\\");\\n container.style.width=\\\"70px\\\";\\n container.style.height=\\\"21px\\\";\\n\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\\\";\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; ' +loader+ '\\\" ></div>';\\n } else {\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; background-image: url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\\\" ></div>';\\n }\\n\\n // create the knob as a GDraggableObject\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\\\";\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.overflow=\\\"hidden\\\";\\n this.knob_img = document.createElement(\\\"div\\\");\\n this.knob_img.style.height=\\\"21px\\\";\\n this.knob_img.style.width=\\\"83px\\\";\\n this.knob_img.style.filter=loader;\\n this.knob_img.style.position=\\\"relative\\\";\\n this.knob_img.style.left=\\\"-70px\\\";\\n this.knob.appendChild(this.knob_img);\\n } else {\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.backgroundImage=\\\"url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\\\";\\n this.knob.style.backgroundPosition=\\\"-70px 0px\\\";\\n }\\n container.appendChild(this.knob);\\n this.slide=new GDraggableObject(this.knob, {container:container});\\n this.slide.setDraggableCursor('pointer');\\n this.slide.setDraggingCursor('pointer');\\n this.container = container;\\n\\n // attach the control to the map\\n map.getContainer().appendChild(container);\\n\\n // init slider\\n this.setSlider(this.opacity);\\n\\n // Listen for the slider being moved and set the opacity\\n GEvent.addListener(this.slide, \\\"dragend\\\", function() {that.setOpacity()});\\n //GEvent.addListener(this.container, \\\"click\\\", function( x, y ) { alert(x, y) });\\n\\n return container;\\n }\\n\\n // Set the default position for the control\\n CTransparencyControl.prototype.getDefaultPosition = function() {\\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\\n }\\n\\n /*\\n * Full-screen Window Resize\\n */\\n\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n // map.checkResize();\\n }\\n\\n\\n /*\\n * Main load function:\\n */\\n\\n function load() {\\n\\n if (GBrowserIsCompatible()) {\\n\\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\\n var gcr = GMapType.prototype.getCopyrights;\\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\\n return [\\\"%(copyright)s\\\"].concat(gcr.call(this,bounds,zoom));\\n }\\n\\n map = new GMap2( document.getElementById(\\\"map\\\"), { backgroundColor: '#fff' } );\\n\\n map.addMapType(G_PHYSICAL_MAP);\\n map.setMapType(G_PHYSICAL_MAP);\\n\\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\\n\\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\\n GEvent.addListener(map, \\\"maptypechanged\\\", function() {\\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\\n map.addOverlay(hybridOverlay);\\\"\\\"\\\" % args\\n if self.kml:\\n s += \\\"\\\"\\\"\\n } else if (map.getCurrentMapType() == G_SATELLITE_3D_MAP) {\\n var url = document.location.toString();\\n if (url.substr(0,4) != 'http') alert('You have to upload the tiles to a webserver to see the overlay in Google Earth Plugin');\\n if (!ge) map.getEarthInstance(getEarthInstanceCB);\\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n } else {\\n map.removeOverlay(hybridOverlay);\\n }\\n } );\\n\\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\\n var mercator = new GMercatorProjection(mapMaxZoom+1);\\n tilelayer.getTileUrl = function(tile,zoom) {\\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n var ymax = 1 << zoom;\\n var y = ymax - tile.y -1;\\n var tileBounds = new GLatLngBounds(\\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\\n );\\n if (mapBounds.intersects(tileBounds)) {\\n return zoom+\\\"/\\\"+tile.x+\\\"/\\\"+y+\\\".%(tileformat)s\\\";\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n // IE 7-: support for PNG alpha channel\\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\\n tilelayer.isPng = function() { return true;};\\n tilelayer.getOpacity = function() { return opacity; }\\n\\n overlay = new GTileLayerOverlay( tilelayer );\\n map.addOverlay(overlay);\\n\\n map.addControl(new GLargeMapControl3D());\\n map.addControl(new GHierarchicalMapTypeControl());\\n map.addControl(new CTransparencyControl( overlay ));\\n \\\"\\\"\\\" % args\\n if self.kml:\\n s += \\\"\\\"\\\"\\n map.addMapType(G_SATELLITE_3D_MAP);\\n \\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n\\n map.enableContinuousZoom();\\n map.enableScrollWheelZoom();\\n\\n map.setMapType(G_HYBRID_MAP);\\n }\\n resize();\\n }\\n \\\"\\\"\\\"\\n if self.kml:\\n s += \\\"\\\"\\\"\\n function getEarthInstanceCB(object) {\\n ge = object;\\n var url = document.location.toString();\\n var newurl = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\\n if (ge) {\\n var link = ge.createLink(\\\"\\\");\\n if (\\\"%(publishurl)s\\\") { link.setHref(\\\"%(publishurl)s/doc.kml\\\") }\\n else { link.setHref(newurl) };\\n var networkLink = ge.createNetworkLink(\\\"\\\");\\n networkLink.set(link, false, false);\\n ge.getFeatures().appendChild(networkLink);\\n } else {\\n // alert(\\\"Initialization of the Google Earth Plugin failed. You can still open the KML file in normal Google Earth.\\\");\\n // window.location = newurl; // JavaScript redirect to the URL of KML\\n }\\n }\\n \\\"\\\"\\\" % args\\n s += \\\"\\\"\\\"\\n onresize=function(){ resize(); };\\n\\n //]]>\\n </script>\\n </head>\\n <body onload=\\\"load()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"https://github.com/mj10777/mapmbtiles\\\">MapMbTiles</a>/<a href=\\\"http://www.klokan.cz/projects/gdal2mbtiles/\\\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n </body>\\n </html>\\n \\\"\\\"\\\" % args\\n\\n return s\",\n \"def _call_geocoder(self, url, raw=False):\\n try:\\n page = self.urlopen(url)\\n except HTTPError as error:\\n raise GeocoderServiceError(error.getcode(), getattr(error, 'msg', None))\\n if raw:\\n return page\\n return json.loads(decode_page(page))\",\n \"def google_geocode(query):\\n\\tif not API_KEY:\\n\\t\\traise ConfigException(\\\"Require API_KEY for googleapi. Reload after setting.\\\")\\n\\td = {\\\"address\\\" : query.encode(\\\"utf-8\\\"), \\\"key\\\" : API_KEY }\\n\\tf = urlopen(LOC_URL % (urlencode(d)))\\n\\tlocdata = load(f)\\n\\tif f.getcode() == 200:\\n\\t\\tif \\\"results\\\" in locdata:\\n\\t\\t\\titem = locdata[\\\"results\\\"]\\n\\t\\t\\tif len(item) == 0:\\n\\t\\t\\t\\treturn None\\n\\t\\t\\titem = item[0]\\n\\t\\t\\tll = item.get(\\\"geometry\\\", {}).get(\\\"location\\\") # lol tricky\\n\\t\\t\\tif not ll: return None\\n\\t\\t\\treturn item[\\\"formatted_address\\\"], ll[\\\"lat\\\"], ll[\\\"lng\\\"]\\n\\t\\telse:\\n\\t\\t\\treturn None\\n\\telse:\\n\\t\\traise RuntimeError(\\\"Error (%s): %s\\\" % (f.getcode(), locdata.replace(\\\"\\\\n\\\", \\\" \\\")))\",\n \"def get_google_results(address, api_key=None, return_full_response=False):\\n # Set up your Geocoding url\\n geocode_url = \\\"https://maps.googleapis.com/maps/api/geocode/json?address={}\\\".format(address) + \\\"&sensor=false\\\"\\n # if api_key is not None:\\n # geocode_url = geocode_url + \\\"&key={}\\\".format(api_key)\\n\\n # Ping google for the reuslts:\\n results = requests.get(geocode_url)\\n\\n # Results will be in JSON format - convert to dict using requests functionality\\n results = results.json()\\n\\n # if there's no results or an error, return empty results.\\n if len(results['results']) == 0:\\n output = {\\n \\\"formatted_address\\\": None,\\n \\\"latitude\\\": None,\\n \\\"longitude\\\": None,\\n \\\"accuracy\\\": None,\\n \\\"google_place_id\\\": None,\\n \\\"type\\\": None,\\n \\\"postcode\\\": None\\n }\\n else:\\n answer = results['results'][0]\\n output = {\\n \\\"formatted_address\\\": answer.get('formatted_address'),\\n \\\"latitude\\\": answer.get('geometry').get('location').get('lat'),\\n \\\"longitude\\\": answer.get('geometry').get('location').get('lng'),\\n \\\"accuracy\\\": answer.get('geometry').get('location_type'),\\n \\\"google_place_id\\\": answer.get(\\\"place_id\\\"),\\n \\\"type\\\": \\\",\\\".join(answer.get('types')),\\n \\\"postcode\\\": \\\",\\\".join([x['long_name'] for x in answer.get('address_components')\\n if 'postal_code' in x.get('types')])\\n }\\n\\n # Append some other details:\\n output['input_string'] = address\\n output['number_of_results'] = len(results['results'])\\n output['status'] = results.get('status')\\n if return_full_response is True:\\n output['response'] = results\\n\\n return output\",\n \"def get_google_results(api_id, address, return_response_fields=None):\\n # set up api key\\n api_key = \\\"AIzaSyDQaVh67imEZW2FLH7hb33SB63jv2shkqQ\\\"\\n request_url = \\\"\\\"\\n outputs = []\\n building = address[0]\\n address1 = address[0] + \\\" \\\" + address[1] + \\\" \\\" + address[2]\\n if api_id == \\\"geocoding\\\":\\n request_url = \\\"https://maps.googleapis.com/maps/api/geocode/json?address={}\\\".format(\\n address1) + \\\"&key={}\\\".format(\\n api_key)\\n print(\\\"GEOCODING |||||||||| \\\" + request_url)\\n if api_id == \\\"nearbysearch\\\":\\n lat_long = get_google_results(\\\"geocoding\\\", address, return_response_fields=\\\"latitude\\\")[0][\\n \\\"latitude\\\"].__str__() + \\\",\\\" + \\\\\\n get_google_results(\\\"geocoding\\\", address, return_response_fields=\\\"longitude\\\")[0][\\n \\\"longitude\\\"].__str__()\\n request_url = \\\"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={}\\\".format(\\n lat_long) + \\\"&rankby=distance&type=establishment&key={}\\\".format(api_key)\\n print(\\\"NEARBYSEARCH |||||||||| \\\" + request_url)\\n results = requests.get(request_url)\\n results = results.json()\\n\\n if len(results['results']) == 0:\\n return False\\n else:\\n for answer in results['results']:\\n if api_id == \\\"geocoding\\\":\\n\\n street_number = \\\"0\\\"\\n for y in answer.get('address_components'):\\n if 'street_number' in y.get('types'): street_number = y['long_name']\\n\\n route_name = \\\"0\\\"\\n for z in answer.get('address_components'):\\n if 'route' in z.get('types'): route_name = z['long_name']\\n\\n output = {\\n \\\"entry\\\": building,\\n \\\"street_number\\\": street_number,\\n \\\"route_name\\\": route_name,\\n \\\"latitude\\\": answer.get('geometry').get('location').get('lat'),\\n \\\"longitude\\\": answer.get('geometry').get('location').get('lng'),\\n \\\"google_place_id\\\": answer.get(\\\"place_id\\\"),\\n \\\"type\\\": \\\",\\\".join(answer.get('types')),\\n \\\"postcode\\\": \\\",\\\".join(\\n [x['long_name'] for x in answer.get('address_components') if 'postal_code' in x.get('types')]),\\n\\n }\\n if (output[\\\"route_name\\\"]) == \\\"0\\\":\\n output[\\\"route_name\\\"] = answer.get('formatted_address')\\n if (output[\\\"street_number\\\"]) == \\\"0\\\":\\n\\n pattern = re.compile(\\\"^(.+?),\\\")\\n pattern0 = re.compile(\\\",(.+?),\\\")\\n patterns = [pattern, pattern0]\\n for pat in patterns:\\n if pat.search(answer.get('formatted_address')):\\n\\n ad = re.findall(pat, answer.get('formatted_address'))[0]\\n pattern1 = re.compile(\\\"\\\\d+\\\")\\n if pattern1.search(ad):\\n ad1 = re.findall(pattern1, ad)[0]\\n if len(ad1) < 4: output[\\\"street_number\\\"] = ad1\\n\\n outputs += [output]\\n\\n if api_id == \\\"nearbysearch\\\":\\n street_number = \\\"0\\\"\\n route_name = answer.get('vicinity')\\n if answer.get('rating') is None:\\n rating = 0\\n else:\\n rating = int(answer.get('rating'))\\n\\n output = {'input_string': address1, \\\"street_number\\\": street_number, \\\"route_name\\\": route_name,\\n \\\"google_place_id\\\": answer.get(\\\"place_id\\\"), \\\"type\\\": \\\",\\\".join(answer.get('types')),\\n \\\"rating\\\": rating}\\n\\n pattern = re.compile(\\\"^(.+?),\\\")\\n pattern0 = re.compile(\\\",(.+?),\\\")\\n patterns = [pattern, pattern0]\\n for pat in patterns:\\n if pat.search(route_name):\\n\\n ad = re.findall(pat, answer.get('vicinity'))[0]\\n pattern1 = re.compile(\\\"\\\\d+\\\")\\n if pattern1.search(ad):\\n ad1 = re.findall(pattern1, ad)[0]\\n if len(ad1) < 4: output[\\\"street_number\\\"] = ad1\\n\\n if output[\\\"street_number\\\"] == address[0]:\\n outputs += [output]\\n\\n if return_response_fields is None and len(outputs) > 0:\\n return outputs\\n elif (len(outputs) > 0) and (return_response_fields is not None):\\n output_filter = []\\n for item in outputs:\\n output_filter += [{\\\"\\\" + return_response_fields: item[return_response_fields]}]\\n outputs = output_filter\\n return outputs\\n else:\\n return False\",\n \"def test_google_return(monkeypatch):\\n ADD = \\\"7 Cité Paradis, 75010 Paris, France\\\"\\n LAT = 48.8748465\\n LNG = 2.3504873\\n NAME = \\\"openclassrooms\\\"\\n RESULTS = {\\n \\\"candidates\\\": [\\n {\\n \\\"formatted_address\\\": ADD,\\n \\\"geometry\\\": {\\n \\\"location\\\": {\\n \\\"lat\\\": LAT,\\n \\\"lng\\\": LNG\\n },\\n\\n },\\n \\\"name\\\": NAME\\n\\n }\\n ]\\n\\n }\\n\\n class MockGet:\\n def __init__(self,*args, **kwargs):\\n pass\\n\\n def json(self):\\n return RESULTS\\n\\n monkeypatch.setattr('requests.get', MockGet)\\n script = GoogleMapApi()\\n response = script.search_about_query(query='openclassrooms', g_key=1).json()\\n assert response['candidates'][0]['formatted_address'] == ADD\",\n \"def __init__(self):\\n self.service = Client(key=GEO_LOCATION_API_KEY)\",\n \"def main():\\r\\n # establishes start end and time data\\r\\n query_user()\\r\\n # returns optimal subway stop\\r\\n subway_stop_location = determine_optimal_CTA()\\r\\n # returns the time you need to arrive at the CTA\\r\\n arrival_time_transit = determine_arrival_time(subway_stop_location)\\r\\n # launches directions in google maps, with two windows for directions to and from CTA\\r\\n # launch_directions(arrival_time_transit, subway_stop_location)\\r\",\n \"def small_map(self):\\n self.map_url = \\\"https://maps.googleapis.com/maps/api/staticmap?center={},{}&zoom=12&size=350x350&key={}\\\".format(self.lat, self.lng, api_key) \\n return (self.map_url)\",\n \"def get_google_geocoding(coordinates):\\n latitude = coordinates['latitude']\\n longitude = coordinates['longitude']\\n payload = build_google_payload(latitude=latitude, longitude=longitude)\\n response = requests.get(google_url, params=payload, timeout=int(GEOCODING_INFO['timeout']))\\n if response.status_code == 200:\\n formated_data = extract_data_from_google_response(response.text.encode('utf-8'))\\n return formated_data\\n else:\\n return None\",\n \"def get_google_results(address):\\n\\t# Set up your Geocoding url\\n\\tlogging.info(\\\"[GOOGLE URL]: init\\\")\\n\\tparams = {\\n\\t\\\"address\\\":address,\\n\\t\\\"key\\\":GEOPY.get('AQUEDUCT_GOOGLE_PLACES_PRIVATE_KEY')\\n\\t}\\n\\t\\n\\t# Ping google for the reuslts:\\n\\ttry:\\n\\t\\twith requests.Session() as s:\\n\\t\\t\\ts.mount('https://',HTTPAdapter(max_retries=Retry(2, backoff_factor=0.001)))\\n\\t\\t\\tr = s.get(url=GEOCODE_URL, params=params, timeout=5)\\n\\t\\t\\n\\t\\tif r.status_code == requests.codes.ok:\\n\\t\\t\\t# Results will be in JSON format - convert to dict using requests functionality\\n\\t\\t\\tresults = r.json()\\n\\t\\t\\t# if there's no results or an error, return empty results.\\n\\t\\t\\tif len(results['results']) == 0:\\n\\t\\t\\t\\toutput = {\\n\\t\\t\\t\\t\\t\\\"matched_address\\\" : None,\\n\\t\\t\\t\\t\\t\\\"lat\\\": None,\\n\\t\\t\\t\\t\\t\\\"lon\\\": None,\\n\\t\\t\\t\\t\\t\\\"match\\\": False\\n\\t\\t\\t\\t}\\n\\t\\t\\telse: \\n\\t\\t\\t\\tanswer = results['results'][0]\\n\\t\\t\\t\\toutput = {\\n\\t\\t\\t\\t\\t\\\"matched_address\\\" : answer.get('formatted_address'),\\n\\t\\t\\t\\t\\t\\\"lat\\\": answer.get('geometry').get('location').get('lat'),\\n\\t\\t\\t\\t\\t\\\"lon\\\": answer.get('geometry').get('location').get('lng'),\\n\\t\\t\\t\\t\\t\\\"match\\\":True\\n\\t\\t\\t\\t}\\n\\t\\telse:\\n\\t\\t\\tlogging.error(f\\\"[GEOCODER: Get google place]: {r.text}\\\")\\n\\t\\t\\tlogging.error(f\\\"[GEOCODER- GOOGLE URL]: {r.status_code}\\\")\\n\\t\\t\\toutput = {\\n\\t\\t\\t\\t\\\"matched_address\\\" : None,\\n\\t\\t\\t\\t\\\"lat\\\": None,\\n\\t\\t\\t\\t\\\"lon\\\": None,\\n\\t\\t\\t\\t\\\"match\\\": False\\n\\t\\t\\t}\\n\\t\\t\\t\\n\\t\\t# Append some other details: \\n\\t\\toutput['address'] = address\\n\\t\\toutput['number_of_results'] = len(results['results'])\\n\\t\\toutput['status'] = results.get('status')\\n\\t\\t\\n\\t\\treturn output\\n\\texcept Exception as e:\\n\\t\\traise e\",\n \"def test_view_geocoder_success(self, google):\\n google.return_value = GeocoderMock()\\n\\n view = super(BaseSearchPageViewTestCase, self).initialize(BaseSearchPageView(), None)\\n\\n response = view.geocode_location('Test, Test')\\n\\n # Check geocoder returns a list of [0,1]\\n self.assertListEqual(response, [0,1])\",\n \"def scrapping():\\r\\n\\r\\n data_cust = {}\\r\\n #token, latitude, longitude, name, place_id, types_places, vicinity = [],[],[],[],[],[], []\\r\\n\\r\\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\\r\\n urls = 'https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={},{}&radius={}&key={}&type={}&keyword={}'.format(\\r\\n lat_ori, long_ori, radius, apik, types_user, keyword_user)\\r\\n r = requests.get(urls)\\r\\n data_cust['0'] = r.json()\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n CODE FOR NEXT PAGE TOKEN\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n for number in range(10):\\r\\n\\r\\n content = str(number)\\r\\n if 'next_page_token' in data_cust[content].keys():\\r\\n sleep(5)\\r\\n pagetoken = data_cust[content]['next_page_token']\\r\\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\\r\\n urls = 'https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={},{}&radius={}&type={}&keyword={}&key={}{pagetoken}'.format(\\r\\n lat_ori, long_ori, radius, types_user, keyword_user, apik, pagetoken=\\\"&pagetoken=\\\"+pagetoken if pagetoken else \\\"\\\")\\r\\n r = requests.get(urls)\\r\\n get = requests.post(urls)\\r\\n print(get)\\r\\n new_id = str(number+1)\\r\\n data_cust[new_id] = r.json()\\r\\n else:\\r\\n print(\\\"Done\\\")\\r\\n break\\r\\n\\r\\n latitude, longitude, name, place_id, types_places, vicinity = [], [], [], [], [], []\\r\\n for i in range(number+1):\\r\\n content = str(i)\\r\\n for numbers in range(len(data_cust[content]['results'])):\\r\\n latitude.append(data_cust[content]['results']\\r\\n [numbers]['geometry']['location']['lat'])\\r\\n longitude.append(data_cust[content]['results']\\r\\n [numbers]['geometry']['location']['lng'])\\r\\n name.append(data_cust[content]['results'][numbers]['name'])\\r\\n place_id.append(data_cust[content]['results'][numbers]['place_id'])\\r\\n types_places.append(\\r\\n data_cust[content]['results'][numbers]['types'][0])\\r\\n vicinity.append(data_cust[content]['results'][numbers]['vicinity'])\\r\\n\\r\\n datacustype = pd.DataFrame({'customer_name': name, 'customer_type': types_places, 'place_id': place_id,\\r\\n 'keyword': keyword_user, 'radius': radius, 'latitude_origin': lat_ori, 'longitude_origin': long_ori, 'latitude_destination': latitude,\\r\\n 'longitude_destination': longitude})\\r\\n datacustype\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n PHONE NUMBER\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n data_number = {}\\r\\n for number in datacustype['place_id'].values:\\r\\n apik = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E'\\r\\n urls = 'https://maps.googleapis.com/maps/api/place/details/json?place_id={}&fields=name,formatted_address,rating,formatted_phone_number&key={}'.format(\\r\\n number, apik)\\r\\n r = requests.get(urls)\\r\\n data_number[number] = r.json()\\r\\n\\r\\n data_number\\r\\n\\r\\n datanumb = pd.DataFrame.from_dict(data_number).T.reset_index()\\r\\n datanumb.columns = ['place_id', 'html_attributions', 'result', 'status']\\r\\n datanumb\\r\\n\\r\\n name, phone, alamat = [], [], []\\r\\n\\r\\n for number in range(len(datanumb)):\\r\\n if datanumb['status'][number] == 'NOT_FOUND':\\r\\n name.append('Unknown')\\r\\n phone.append(0)\\r\\n alamat.append('-')\\r\\n else:\\r\\n name.append(datanumb['result'][number]['name'])\\r\\n alamat.append(datanumb['result'][number]['formatted_address'])\\r\\n if 'formatted_phone_number' in (datanumb['result'][number].keys()):\\r\\n phone.append(datanumb['result'][number]\\r\\n ['formatted_phone_number'])\\r\\n else:\\r\\n phone.append(0)\\r\\n\\r\\n datanumb2 = pd.DataFrame(\\r\\n {'customer_name': name, 'customer_address': alamat, 'phone_number': phone})\\r\\n datanumb2['place_id'] = datanumb['place_id']\\r\\n datanumb2\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n DATA MERGE\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n datamerge = datacustype.merge(datanumb2, how='left', on='place_id')\\r\\n datamerge\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n DUMMY\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n datadummy = datamerge.copy()\\r\\n datadummy\\r\\n\\r\\n datadummydrop = datadummy.drop(['customer_name_y'], axis=1)\\r\\n datadummydrop.rename(\\r\\n columns={'customer_name_x': 'customer_name'}, inplace=True)\\r\\n datadummydrop2 = datadummydrop[['customer_name', 'customer_address', 'customer_type', 'keyword', 'radius',\\r\\n 'place_id', 'latitude_origin', 'longitude_origin', 'latitude_destination', 'longitude_destination', 'phone_number']]\\r\\n datadummydrop2\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n DISTANCE MATRIX\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n API_key = 'AIzaSyDiFSOQvPbWVh3voJPSSORT9TSfKAXMy7E' # enter Google Maps API key\\r\\n gmaps = googlemaps.Client(key=API_key)\\r\\n\\r\\n distancedrive, distancewalks = [], []\\r\\n\\r\\n # Loop through each row in the data frame using pairwise\\r\\n for number in range(datadummydrop2.shape[0]):\\r\\n # Assign latitude and longitude as origin/departure points\\r\\n LatOrigin = datadummydrop2['latitude_origin'][number]\\r\\n LongOrigin = datadummydrop2['longitude_origin'][number]\\r\\n origins = (LatOrigin, LongOrigin)\\r\\n\\r\\n # Assign latitude and longitude from the next row as the destination point\\r\\n # Save value as lat\\r\\n LatDest = datadummydrop2['latitude_destination'][number]\\r\\n # Save value as lat\\r\\n LongDest = datadummydrop2['longitude_destination'][number]\\r\\n destination = (LatDest, LongDest)\\r\\n\\r\\n # pass origin and destination variables to distance_matrix function# output in meters\\r\\n result = gmaps.distance_matrix(origins, destination, mode='driving', avoid='tolls',\\r\\n units='metric', departure_time=1703981100)[\\\"rows\\\"][0][\\\"elements\\\"][0][\\\"distance\\\"][\\\"value\\\"]\\r\\n # 1703981100 #1606867500\\r\\n # append result to list\\r\\n distancedrive.append(result)\\r\\n\\r\\n datadummydrop2['distance_driving'] = distancedrive\\r\\n datadummydrop3 = datadummydrop2.sort_values(\\r\\n by=['distance_driving'], ascending=True, ignore_index=True)\\r\\n datadummydrop3\\r\\n\\r\\n \\\"\\\"\\\"\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n\\r\\n DATAFRAME TO POSTGRE\\r\\n\\r\\n /////////////////////////////////////////////////////////////////////////////\\r\\n \\\"\\\"\\\"\\r\\n\\r\\n database = psycopg2.connect(database=\\\"customerDB\\\",\\r\\n user=\\\"postgres\\\",\\r\\n password=\\\"1234\\\",\\r\\n host=\\\"localhost\\\")\\r\\n\\r\\n cursor = database.cursor()\\r\\n\\r\\n for i in datadummydrop3.index:\\r\\n c1 = datadummydrop3['customer_name'][i]\\r\\n c2 = datadummydrop3['customer_address'][i]\\r\\n c3 = datadummydrop3['customer_type'][i]\\r\\n c4 = datadummydrop3['keyword'][i]\\r\\n c5 = datadummydrop3['radius'][i]\\r\\n c6 = datadummydrop3['place_id'][i]\\r\\n c7 = datadummydrop3['latitude_origin'][i]\\r\\n c8 = datadummydrop3['longitude_origin'][i]\\r\\n c9 = datadummydrop3['latitude_destination'][i]\\r\\n c10 = datadummydrop3['longitude_destination'][i]\\r\\n c11 = datadummydrop3['phone_number'][i]\\r\\n c12 = datadummydrop3['distance_driving'][i]\\r\\n query = \\\"\\\"\\\"\\r\\n Insert into customertarget_customerpotential(customer_name, customer_address, customer_type, keyword, radius, place_id, latitude_origin, longitude_origin, latitude_destination, longitude_destination, phone_number, distance_driving) VALUES('%s','%s','%s','%s','%s','%s',%s,%s,%s,%s,'%s',%s);\\r\\n \\\"\\\"\\\" % (c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12)\\r\\n cursor.execute(query)\\r\\n cursor.close()\\r\\n\\r\\n database.commit()\\r\\n database.close()\\r\\n\\r\\n print(\\\"Data berhasil di upload\\\")\",\n \"def send_map_data():\\n\\n avg_lat = 37.75774\\n avg_long = -122.43870\\n bounds = {'lat': [-122.54, -122.35], 'lng': [37.67, 37.84]}\\n center = {'lat': avg_lat, 'lng': avg_long}\\n\\n return jsonify({'map_center': center,\\n 'map_bounds': bounds,\\n })\",\n \"def query_google(lat='38.890762', lon='-77.084755', radius='400', keywords=['coffee', 'cafe', 'brunch']):\\n base_url = \\\"https://maps.googleapis.com/maps/api/place/nearbysearch/json\\\"\\n location = f\\\"{lat}, {lon}\\\"\\n for kw in keywords:\\n params = {\\n \\\"key\\\": codecs.decode(config['google']['api_key'], 'rot-13'),\\n \\\"type\\\": 'food',\\n \\\"rankby\\\": 'prominence',\\n \\\"location\\\": location,\\n \\\"radius\\\": radius,\\n \\\"keyword\\\": kw\\n }\\n\\n try:\\n response = requests.get(base_url, params=params).json()\\n key_results_list = response['results']\\n except Exception as e:\\n print(f'error in query_google {e}')\\n\\n #passes to this point\\n print(f'query_google - key_results_list: {key_results_list}')\\n\\n if \\\"next_page_token\\\" in response:\\n params = {\\n \\\"key\\\": codecs.decode(config['google']['api_key'], 'rot-13'),\\n \\\"type\\\": 'food',\\n \\\"rankby\\\": 'prominence',\\n \\\"location\\\": location,\\n \\\"radius\\\": radius,\\n \\\"keyword\\\": kw,\\n \\\"pagetoken\\\": response[\\\"next_page_token\\\"]\\n }\\n\\n response_next_page = requests.get(base_url, params=params).json()\\n key_results_list = key_results_list + response_next_page['results']\\n print(response_next_page)\\n\\n else:\\n print(\\\"no next page\\\")\\n\\n for kr in key_results_list:\\n kr[\\\"keyword\\\"] = kw\\n print(f'key results list length is: {len(kr)}')\\n\\n #db.get_collection(\\\"google_places\\\").delete_many({}) # This needs to be moved into Flask to aggregate results\\n db.get_collection(\\\"google_places\\\").insert_many(key_results_list)\",\n \"def geocodeLocations(locations):\\n maxResults = 1\\n location_query = ''\\n for location in locations:\\n location_query += \\\"&location=%s\\\" % encodeUrl(location)\\n url = \\\"http://open.mapquestapi.com/geocoding/v1/batch?maxResults=%d%s\\\" % (maxResults, location_query)\\n print url\\n results = json.loads(urllib2.urlopen(url).read())\\n print results\\n return\\n for location_result in results['results']:\\n #print location_result\\n if location_result['providedLocation']['location'] == location:\\n latlng = location_result['locations'][0]['displayLatLng']\\n return latlng\\n else:\\n print location_result\",\n \"def __init__(self, locality=False):\\n self.google = googlemaps.Client(key=os.environ['GOOGLE_API_KEY'])\\n\\n if locality:\\n self.bounds = self.bound(locality)\\n self.northeast, self.southwest = self.nad83(self.bounds.northeast), self.nad83(self.bounds.southwest)\\n self.geography = self.grid(self.northeast, self.southwest)\\n\\n return None\",\n \"def test_get_place(self):\\n req_data = jsonify({\\\"lat\\\": 28.615551,\\n \\\"long\\\": 77.224091})\\n res = req.post(get_place_url, json=req_data)\\n self.assertEqual(\\\"200\\\", json.loads(res.text)[\\\"Status\\\"])\",\n \"def __init__(self, place):\\n self.place = place\\n self.cleanplace = parser(self.place)\\n self.key = googlemaps.Client(key=os.environ.get(\\\"GMAP_KEY\\\") or GMAP_KEY)\\n self.response = self.search()\\n self.latitude = self.response[0][\\\"geometry\\\"][\\\"location\\\"][\\\"lat\\\"]\\n self.longitude = self.response[0][\\\"geometry\\\"][\\\"location\\\"][\\\"lng\\\"]\\n self.address = self.response[0][\\\"formatted_address\\\"]\\n self.wiki = self.response[0][\\\"address_components\\\"][1][\\\"long_name\\\"]\",\n \"def get_static_google_map(filename_wo_extension, center=None, zoom=None, imgsize=\\\"640x640\\\", imgformat=\\\"png\\\",\\n maptype=\\\"roadmap\\\", markers=None):\\n\\n # assemble the URL\\n # base URL, append query params, separated by &\\n request = \\\"http://maps.google.com/maps/api/staticmap?\\\"\\n apiKey = os.getenv('GOOGLE_MAPS_API_KEY')\\n # if center and zoom are not given, the map will show all marker locations\\n request += \\\"key=%s&\\\" % apiKey\\n if center != None:\\n request += \\\"center=%s&\\\" % center\\n if zoom != None:\\n # zoom 0 (all of the world scale ) to 22 (single buildings scale)\\n request += \\\"zoom=%i&\\\" % zoom\\n\\n request += \\\"size=%ix%i&\\\" % (imgsize) # tuple of ints, up to 640 by 640\\n request += \\\"format=%s&\\\" % imgformat\\n request += \\\"bearing=90&\\\"\\n # request += \\\"maptype=%s&\\\" % maptype # roadmap, satellite, hybrid, terrain\\n\\n # add markers (location and style)\\n if markers != None:\\n for marker in markers:\\n request += \\\"%s&\\\" % marker\\n\\n request = request.rstrip('&')\\n # #request += \\\"mobile=false&\\\" # optional: mobile=true will assume the image is shown on a small screen (mobile device)\\n # request += \\\"sensor=false\\\" # must be given, deals with getting loction from mobile device\\n # try:\\n urllib.request.urlretrieve(request, filename_wo_extension)\",\n \"def maps(request):\\n #convert image locations to google maps parsable points\\n now = datetime.utcnow().replace(tzinfo=utc)\\n latlngs = search_utils.filter_date(search_utils.min_date, now)\\n points = [search_utils.to_map_point(image) for image in latlngs]\\n #load the search form sidebar\\n t = loader.get_template(\\\"wainz/search_form.html\\\")\\n ctx = Context({})\\n search_form = t.render(ctx)\\n\\n return render_to_response('wainz/maps.html', {\\\"latLngs\\\":points, \\\"search_form\\\":search_form, \\\"typeAheadTags\\\":Tag.objects.all()}, context_instance = RequestContext(request))\",\n \"def geocode():\\n\\n if \\\"location\\\" in request.vars:\\n location = request.vars.location\\n else:\\n session.error = T(\\\"Need to specify a location to search for.\\\")\\n redirect(URL(r=request, f=\\\"index\\\"))\\n\\n if \\\"service\\\" in request.vars:\\n service = request.vars.service\\n else:\\n # @ToDo: service=all should be default\\n service = \\\"google\\\"\\n\\n if service == \\\"google\\\":\\n return s3base.GoogleGeocoder(location, db).get_kml()\\n\\n if service == \\\"yahoo\\\":\\n return s3base.YahooGeocoder(location, db).get_xml()\",\n \"def send_request(origin_addresses, dest_addresses, api):\\n def build_address_str(addresses):\\n # Build a pipe-separated string of addresses\\n address_str = ''\\n for i in range(len(addresses) - 1):\\n address_str += addresses[i] + '|'\\n address_str += addresses[-1]\\n return address_str\\n\\n request = 'https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial'\\n origin_address_str = build_address_str(origin_addresses)\\n dest_address_str = build_address_str(dest_addresses)\\n request = request + '&origins=' + origin_address_str + '&destinations=' + \\\\\\n dest_address_str + '&key=' + api\\n jsonResult = urllib.request.urlopen(request).read().decode(\\\"utf-8\\\")\\n response = json.loads(jsonResult)\\n return response\",\n \"def ajax_solve():\\n\\n # The possible errors and their human-readable messages\\n ERRORS = {\\n 403: \\\"Google Directions could not find a path\\\",\\n 404: \\\"Google Directions did not send response\\\",\\n 405: \\\"You did not specify a start\\\",\\n 406: \\\"You need to specify at least two waypoints\\\",\\n 407: \\\"You did not specify a valid algorithm\\\",\\n 408: \\\"Internal Algorithm Error\\\",\\n\\n }\\n\\n\\n def to_tuple(waypoint):\\n \\\"\\\"\\\"\\n Converts LatLng dicts to tuples.\\n\\n :param waypoint: A waypoint as string, tuple or LatLng dict\\n :return: waypoint, if waypoint is string or tuple,\\n a tuple of the lat and lng values, if dict\\n\\n \\\"\\\"\\\"\\n if isinstance(waypoint, dict):\\n return (waypoint[\\\"lat\\\"], waypoint[\\\"lng\\\"])\\n else:\\n return waypoint\\n\\n def to_dict(waypoint):\\n \\\"\\\"\\\"\\n Converts to tuples to LatLng dicts.\\n\\n :param waypoint: A waypoint as string or tuple\\n :return: waypoint, if waypoint is string or tuple,\\n a LatNg dict, if tuple\\n \\\"\\\"\\\"\\n if isinstance(waypoint, tuple):\\n return {\\\"lat\\\": waypoint[0], \\\"lng\\\": waypoint[1]}\\n else:\\n return waypoint\\n\\n\\n\\n # Get the arguments\\n json = request.args\\n\\n # Check that a start point is supplied\\n start = json.get(\\\"origin\\\")\\n if not start:\\n return jsonify(status=406, msg=ERRORS[405])\\n\\n # Convert to tuple if necessary\\n # This is needed to store waypoints as keys in a dict\\n start = to_tuple(start)\\n\\n\\n\\n waypoints = json.getlist(\\\"waypoints[]\\\")\\n if not waypoints:\\n return jsonify(status=406, msg=ERRORS[406])\\n\\n # We need to have at least two points for a path\\n if len(waypoints) < 2:\\n return jsonify(status=406, msg=ERRORS[406])\\n\\n # Convert to tuple if necessary\\n # This is needed to store waypoints as keys in a dict\\n waypoints = map(to_tuple, waypoints)\\n\\n # Get the algorithm\\n algorithm = algorithms[json[\\\"algo\\\"]]\\n if not algorithm:\\n return jsonify(status=407, msg=ERRORS[407])\\n\\n # Get the options\\n options = {}\\n for option in algorithm.options():\\n options[option] = float(json.get(\\\"options[%s]\\\" % option))\\n\\n try:\\n distances = matrix.create(waypoints)\\n except BaseException as e:\\n logging.warning(\\\"Exception %s while creating matrix for %s\\\" % (e, waypoints))\\n return jsonify(status=404, msg=ERRORS[404])\\n else:\\n if distances:\\n\\n try:\\n # Call the algorithm\\n l, path = algorithm.solve(start, distances, **options)\\n except BaseException as e:\\n logging.warning(\\\"Exception %s while executing %s with %s\\\" % (e, algorithm.name, options))\\n return jsonify(status=408, msg=ERRORS[408])\\n else:\\n # Pack result\\n result = {\\n \\\"status\\\": 200,\\n \\\"length\\\": l,\\n \\\"start\\\": start,\\n \\\"algo\\\": json[\\\"algo\\\"],\\n \\\"path\\\": map(to_dict, path),\\n \\\"msg\\\": \\\"SUCCESS\\\"\\n }\\n\\n # Return the result\\n return jsonify(result)\\n else:\\n return jsonify(status=403, msg=ERRORS[403])\",\n \"def __init__(self, lat, lon, api):\\n self.lat = lat\\n self.lon = lon\\n self.api = api\\n self.result = {}\",\n \"def GoogleAPIele(self):\\n import urllib.request\\n import json\\n \\n self.elevation = []\\n Base_url = \\\"https://maps.googleapis.com/maps/api/elevation/json?locations=\\\"\\n APIkey = \\\"&key=AIzaSyDOo1DAojYoYf3WCcadLrsl9PZbnougbtE\\\"\\n \\n for i in range(self.nodenum):\\n Para_url = \\\"%s,%s\\\" % (self.latitude[i], self.longitude[i])\\n url = Base_url + Para_url + APIkey\\n \\n with urllib.request.urlopen(url) as f:\\n response = json.loads(f.read().decode())\\n \\n self.elevation.append(response['results'][0]['elevation'])\",\n \"async def gethotelsinfo(url, key):\\n async with aiohttp.ClientSession() as client:\\n response = await client.request('GET', url)\\n text = await response.read()\\n # we create a google maps object.\\n gmaps = googlemaps.Client(key=key)\\n parser = BeautifulSoup(text, 'html.parser')\\n current_timestamp_utc = datetime.utcnow()\\n hotelreview = {}\\n hotelreview.update({'url':url,'insert_time_utc':current_timestamp_utc})\\n # name\\n try:\\n name = parser.find(class_=\\\"heading_title\\\").get_text()\\n title = re.sub('\\\\n', '', name)\\n except:\\n title = None\\n hotelreview.update({'title':title})\\n # address\\n try:\\n address = parser.find(class_=\\\"content hidden\\\").get_text('')\\n except:\\n address = None\\n hotelreview.update({'address':address})\\n # latitude and longitude\\n if address is None:\\n latitude = None\\n longitude = None\\n hotelreview.update({'location': None})\\n else:\\n try:\\n # we make the request to the google maps API.\\n geocode_result = gmaps.geocode(address)\\n latitude = geocode_result[0]['geometry']['location']['lat']\\n longitude = geocode_result[0]['geometry']['location']['lng']\\n hotelreview.update({'location': str(latitude) + ',' + str(longitude)})\\n except:\\n latitude = None\\n longitude = None\\n hotelreview.update({'location':None})\\n # zipcode.\\n try:\\n raw_zipcode = parser.find(class_=\\\"content hidden\\\").find(class_=\\\"locality\\\").get_text('')\\n zipcode = int(raw_zipcode.split(' ')[0])\\n except:\\n zipcode = None\\n hotelreview.update({'zipcode':zipcode})\\n # city\\n try:\\n raw_city = parser.find(class_=\\\"content hidden\\\").find(class_=\\\"locality\\\").get_text('')\\n city = raw_city.split(' ')[1].replace(',', '')\\n except:\\n city = None\\n hotelreview.update({'city':city})\\n # rooms\\n try:\\n numberofrooms = int(parser.find(class_=\\\"list number_of_rooms\\\").get_text(';').split(';')[1])\\n except:\\n numberofrooms = None\\n hotelreview.update({'numberofrooms':numberofrooms})\\n # stars\\n try:\\n stars = parser.find(class_=\\\"starRating detailListItem\\\").get_text(';').split(';')[1]\\n except:\\n stars = None\\n hotelreview.update({'stars':stars})\\n # services\\n try:\\n service = str([i.get_text(';') for i in parser.find(class_=\\\"detailsMid\\\").\\n findAll(class_=\\\"highlightedAmenity detailListItem\\\")]).replace(\\\"'\\\", \\\"\\\")\\n except:\\n service = None\\n hotelreview.update({'service':service})\\n # price\\n try:\\n prices = parser.find(class_=\\\"list price_range\\\").get_text(';').replace('\\\\xa0', '')\\n minprice = int(prices.split(';')[1].split('€')[0])\\n maxprice = int(prices.split(';')[1].split('-')[1].split(\\\"€\\\")[0])\\n except:\\n minprice = None\\n maxprice = None\\n hotelreview.update({'minprice':minprice})\\n hotelreview.update({'maxprice':maxprice})\\n #phonenumber\\n try:\\n phone = parser.find(class_=\\\"blEntry phone\\\").get_text()\\n parse_phone = \\\"\\\".join(phone.split())\\n except:\\n parse_phone = None\\n hotelreview.update({'parse_phone':parse_phone})\\n return hotelreview\",\n \"def get_lat_lng(self):\\n self.input_api = '%20'.join(self.parsed_question)\\n self.input_api = ' '.join(self.parsed_question)\\n self.google_api_url = 'https://maps.googleapis.com/maps/api/place/findplacefromtext/json?input={}&inputtype=textquery&fields=geometry,name,place_id&types=point_of_interest&key={}'.format (self.input_api, api_key) \\n self.r = requests.get(url=self.google_api_url)\\n self.data = self.r.json()\\n self.name = self.data['candidates'][0]['name']\\n self.place_id = self.data['candidates'][0]['place_id']\\n self.lat = self.data['candidates'][0]['geometry']['location']['lat']\\n self.lng = self.data['candidates'][0]['geometry']['location']['lng']\\n print(self.lat, self.lng, self.place_id)\\n return (self.lat, self.lng, self.place_id)\",\n \"def get_lat_lng(apiKey,address):\\n \\n url = ('https://maps.googleapis.com/maps/api/geocode/json?address={}&key={}'\\n .format(address.replace(' ','+'), apiKey))\\n try:\\n response = requests.get(url)\\n resp_json_payload = response.json()\\n lat = resp_json_payload['results'][0]['geometry']['location']['lat']\\n lng = resp_json_payload['results'][0]['geometry']['location']['lng']\\n except:\\n print('ERROR: {}'.format(address))\\n lat = 0\\n lng = 0\\n return lat, lng\",\n \"def main(self):\\n question = Parser(self.question)\\n latitude = 0\\n longitude = 0\\n address = \\\"Bonjour, je vais bien merci !\\\"\\n history = self._get_papy_sentence()\\n article_title = \\\"\\\"\\n location = question.get_location()\\n google = GoogleApi(location, self.google_key)\\n google_response = google.parse()\\n if question.get_verification():\\n latitude = google_response['latitude']\\n longitude = google_response['longitude']\\n address = google_response['address']\\n if google_response['status'] == \\\"OK\\\":\\n wiki = WikiApi(google_response['latitude'],\\n google_response['longitude'])\\n wiki_response = wiki.parse()\\n if wiki_response['status'] == \\\"OK\\\":\\n history = wiki_response['history']\\n article_title = wiki_response['article_title']\\n\\n self.response_grandpy = {\\n 'latitude': latitude,\\n 'longitude': longitude,\\n 'address': address,\\n 'history': history,\\n 'article_title': article_title\\n }\\n return self.response_grandpy\",\n \"def main(postalcode):\\n places = postalcodes_mexico.places(postalcode)\\n click.echo(places)\\n return 0\",\n \"def test_doGet(self) -> None:\\n\\n status_code = apicall.doGet(URL, self._browserheader)\\n print(\\\"in do get:\\\", status_code)\\n assert status_code == API_SUCCESS\",\n \"def main(name):\\n user_dict = twitter_api.main(name)\\n if user_dict == \\\"\\\":\\n return \\\"no_name\\\"\\n user_points_dict = coordinates.convert_to_coordinates(user_dict)\\n map.create_map(user_points_dict, name)\",\n \"def main():\\n\\ttile_dimensions = (512, 512)\\n\\ttile_count = (5, 4) \\n\\timage = Image.new(\\\"RGB\\\", (tile_dimensions[0] * tile_count[0], tile_dimensions[1] * tile_count[1]), None)\\n\\n\\ttry:\\n\\t\\turl = sys.argv[1]\\n\\texcept:\\n\\t\\tprint \\\"Please enter a Google Maps URL as a parameter.\\\"\\n\\t\\tprint \\\"Usage: $ python get_pano.py https://www.google.com/maps/@34.1027387,-118.340471,3a,75y,32.1h,87.53t/data=!3m7!1e1!3m5!1soInaTCic7TsAAAQDMaZ31A!2e0!3e2!7i13312!8i6656\\\"\\n\\t\\treturn\\n\\n\\ttry:\\n\\t\\tprint \\\"************************************\\\"\\n\\t\\tprint \\\"Fetching images from Google Maps, this could take some time...\\\"\\n\\t\\tregex = re.compile(r'panoid\\\\=([^&]*)', re.I)\\n\\t\\tpano_id = regex.findall(urllib.unquote(url))[0]\\n\\t\\tfor y in range(tile_count[1]):\\n\\t\\t\\tfor x in range(tile_count[0]):\\n\\t\\t\\t\\timg_url = \\\"https://geo2.ggpht.com/cbk?cb_client=maps_sv.tactile&authuser=0&hl=en&panoid=\\\" + pano_id + \\\"&output=tile&x=\\\"+str(x)+\\\"&y=\\\"+str(y)+\\\"&zoom=3&nbt&fover=2\\\"\\n\\t\\t\\t\\tresponse = urllib2.urlopen(img_url)\\n\\t\\t\\t\\tfile_data = StringIO(response.read())\\n\\t\\t\\t\\timage.paste(Image.open(file_data), (x * tile_dimensions[0], y * tile_dimensions[1]))\\n\\t\\t\\n\\t\\tfilename = \\\"pano-\\\" + pano_id + \\\".jpg\\\"\\n\\t\\timage.save(filename)\\n\\t\\tprint \\\"Success, image saved as \\\\033[96m\\\" + filename + \\\"\\\\033[00m\\\"\\n\\t\\tprint \\\"************************************\\\"\\n\\n\\n\\texcept Exception as e:\\n\\t\\tprint \\\"Sorry something broke.\\\"\\n\\t\\tprint e\",\n \"def __geo_interface__(self):\\n ...\",\n \"def walking():\\r\\n name = request.args[\\\"address\\\"]\\r\\n end_name=request.args[\\\"end_point\\\"]\\r\\n end_lng = request.args[\\\"end_lng\\\"]\\r\\n end_lat = request.args[\\\"end_lat\\\"]\\r\\n end_lng = float(end_lng)\\r\\n end_lat = float(end_lat)\\r\\n start_lng=get_address(name)[1]\\r\\n start_lat=get_address(name)[0]\\r\\n\\r\\n\\r\\n #get coordinates of start and end point\\r\\n map_directions, geojson_str = get_static_map(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n logging.warning(\\\"Map directions %s\\\", str(map_directions))\\r\\n\\r\\n\\r\\n #retrieve instructions\\r\\n instructions = get_map_instructions(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n\\r\\n\\r\\n # generate interactive map\\r\\n return render_template(\\r\\n \\\"page4.html\\\",\\r\\n mapbox_token=MAPBOX_TOKEN,\\r\\n geojson_str=geojson_str,\\r\\n end_name=end_name,\\r\\n name=name,\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lng,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n center_lng=(start_lng + end_lng) / 2,\\r\\n center_lat=(start_lat + end_lat) / 2,\\r\\n instructions=instructions,\\r\\n method = 'Walking'\\r\\n )\",\n \"def process(self):\\n if self.user is not None:\\n async_queries = []\\n \\n # DEBUGGING\\n # prefs = []\\n \\n # Load in preferences\\n for k, v in self.user.preferences.iteritems():\\n for l in self.user.preferences[k]:\\n gmap_search = GoogleMapSearch()\\n gmap_search.parameters['location'] = '40,-88'\\n gmap_search.parameters['radius'] = '10000'\\n gmap_search.parameters['keyword'] = l\\n gmap_search.parameters['language'] = 'en'\\n # gmap_search.parameters['minprice'] = None\\n # gmap_search.parameters['maxprice'] = None\\n # gmap_search.parameters['name'] = None\\n # gmap_search.parameters['opennow'] = None\\n # gmap_search.parameters['rankby'] = None\\n if k != 'keywords': gmap_search.parameters['types'] = k\\n # gmap_search.parameters['pagetoken'] = None\\n \\n # DEBUGGING\\n # prefs.append(gmap_search.parameters)\\n \\n async_queries.append(gmap_search)\\n \\n # Send all requests\\n async_pool = Pool(processes=8)\\n response = async_pool.map(parallel_search, async_queries)\\n filtered_responses = ['']*len(response)\\n for i, r in enumerate(response):\\n filtered_response = {k:v for (k, v) in r.iteritems()}\\n filtered_response['category'] = {'name': None, 'type': None}\\n if async_queries[i].parameters.has_key('type') and async_queries[i].parameters['types'] != '' and async_queries[i].parameters['types'] is not None: filtered_response['category']['name'] = async_queries[i].parameters['types']\\n else: filtered_response['category']['name'] = 'keyword'\\n filtered_response['category']['type'] = async_queries[i].parameters['keyword']\\n filtered_responses[i] = filtered_response\\n return json.dumps(filtered_responses)\\n else: return None\",\n \"def main():\\n #get_lat_long\\n place_name = 'Arlington - Arlington St'\\n # sec_fun = get_lat_long(place_name)\\n # print(sec_fun)\\n # get_nearest_station(sec_fun[0], sec_fun[1]) #\\n # get_nearest_station(42.350009, -71.076077)\\n print(find_stop_near(place_name))\",\n \"def pull_data_from_google(credentials):\\n pass\",\n \"def map_viewing_client():\\n\\n # Read configuration settings\\n config = gis.get_config()\\n if config.opt_gis_layout == 1:\\n window = True\\n else:\\n window = False\\n\\n # @ToDo Make Configurable\\n toolbar = True\\n\\n map = define_map(window=window, toolbar=toolbar, config=config)\\n\\n response.title = T(\\\"Map Viewing Client\\\")\\n return dict(map=map)\",\n \"def get_map_locs(self, CalSwimView):\\n # Initialize query list\\n query_build = []\\n \\n if (CalSwimView.lat and CalSwimView.lng): \\n # Search query has a specified location thus check against intersection of points and polygons in database\\n self.cursor.execute(\\\"SET @center = GeomFromText('POINT(%s %s)');\\\",(float(CalSwimView.lat), float(CalSwimView.lng)))\\n self.cursor.execute(\\\"SET @radius = %s;\\\",(CalSwimView.radius))\\n self.cursor.execute(\\\"\\\"\\\"\\n SET @bbox = CONCAT('POLYGON((',\\n X(@center) - @radius, ' ', Y(@center) - @radius, ',',\\n X(@center) + @radius, ' ', Y(@center) - @radius, ',',\\n X(@center) + @radius, ' ', Y(@center) + @radius, ',',\\n X(@center) - @radius, ' ', Y(@center) + @radius, ',',\\n X(@center) - @radius, ' ', Y(@center) - @radius, '))'\\n );\\n \\\"\\\"\\\")\\n query_build.append(\\\"\\\"\\\"\\n SELECT gd_id, organization, project_name_short, project_name, project_description, data_type, data_target, AsText(location)\\n FROM GeoData\\n WHERE Intersects( location, GeomFromText(@bbox) )\\n AND\\n CASE geometrytype(location)\\n WHEN 'POINT' THEN\\n SQRT(POW( ABS( X(location) - X(@center)), 2) + POW( ABS(Y(location) - Y(@center)), 2 )) < @radius\\n ELSE\\n TRUE\\n END\\n \\\"\\\"\\\")\\n # Search query has at least 1 keyword\\n if len(CalSwimView.keywords) > 0:\\n # Just a few MySQL notes:\\n # Default MySQL operation executes an \\\"OR\\\" search among terms\\n # To make sure all terms are in a given result, \\\"AND\\\" search among terms, then just add prefix \\\"+\\\" before each term\\n # To exclude results with a given term, just add prefix \\\"-\\\" before the term\\n keyword_query = \\\"*, \\\".join(CalSwimView.keywords) +\\\"*\\\" \\n query_build.append(\\\"\\\"\\\" \\n AND\\n MATCH (organization, contact, project_name, project_description, project_funder, data_target, location_description, data_collector, data_type, keyword, other)\\n AGAINST ('%(KeywordQuery)s' IN BOOLEAN MODE)\\n \\\"\\\"\\\" % {\\\"KeywordQuery\\\":keyword_query})\\n else:\\n # Search query does not have a specified location\\n query_build.append(\\\"\\\"\\\"\\n SELECT gd_id, organization, project_name_short, project_name, project_description, data_type, data_target, AsText(location)\\n FROM GeoData\\n \\\"\\\"\\\")\\n # Search query has at least 1 keyword\\n if len(CalSwimView.keywords) > 0:\\n # Just a few MySQL notes:\\n # Default MySQL operation executes an \\\"OR\\\" search among terms\\n # To make sure all terms are in a given result, \\\"AND\\\" search among terms, then just add prefix \\\"+\\\" before each term\\n # To exclude results with a given term, just add prefix \\\"-\\\" before the term\\n keyword_query = \\\"*, \\\".join(CalSwimView.keywords) +\\\"*\\\" \\n query_build.append(\\\"\\\"\\\" \\n WHERE\\n MATCH (organization, contact, project_name, project_description, project_funder, data_target, location_description, data_collector, data_type, keyword, other)\\n AGAINST ('%(KeywordQuery)s' IN BOOLEAN MODE)\\n \\\"\\\"\\\" % {\\\"KeywordQuery\\\":keyword_query})\\n select_query = \\\"\\\\n\\\".join(query_build)\\n #print >> CalSwimView.errors, select_query\\n \\n # execute SQL query using execute() method.\\n self.cursor.execute(select_query)\\n\\n # Fetch a single row using fetchone() method.\\n rows = [] \\n table_data = {}\\n coordinates = []\\n while(1):\\n row=self.cursor.fetchone()\\n if row == None:\\n break \\n coordinates.append( str(row[7]).replace('POINT(','').replace('POLYGON((','').replace(')','') )\\n rows.append( {\\\"c\\\":[{\\\"v\\\":row[0]}, {\\\"v\\\":row[1]}, {\\\"v\\\":row[2]}, {\\\"v\\\":row[3]}, {\\\"v\\\":row[4]}, {\\\"v\\\":row[5]}, {\\\"v\\\":row[6]}]} )\\n \\n # Return search values as json\\n cols = [{\\\"id\\\":'gd_id', \\\"label\\\":'gd_id', \\\"type\\\":'string'},\\n {\\\"id\\\":'organization', \\\"label\\\":'Organization', \\\"type\\\":'string'},\\n {\\\"id\\\":'project_short', \\\"label\\\":'Project Short', \\\"type\\\":'string'},\\n {\\\"id\\\":'project', \\\"label\\\":'Project', \\\"type\\\":'string'},\\n {\\\"id\\\":'description', \\\"label\\\":'Description', \\\"type\\\":'string'}, \\n {\\\"id\\\":'target', \\\"label\\\":'Target', \\\"type\\\":'string'}]\\n table_data[\\\"cols\\\"] = cols\\n table_data[\\\"rows\\\"] = rows\\n # Assign table data to json table data container\\n json_data = {}\\n json_data[\\\"table_data\\\"] = table_data\\n json_data[\\\"coordinates\\\"] = coordinates\\n \\n # Close DB connections \\n self.cursor.close()\\n \\n # Return results\\n return json.dumps(json_data)\",\n \"def test_google_bad_return(monkeypatch):\\n RESULTS = {\\n \\\"candidates\\\": [],\\n \\\"status\\\": \\\"ZERO_RESULTS\\\"\\n }\\n\\n class MockGet:\\n def __init__(self, *args, **kwargs):\\n pass\\n\\n def json(self):\\n return RESULTS\\n\\n monkeypatch.setattr('requests.get', MockGet)\\n script = GoogleMapApi()\\n response = script.search_about_query(query='kjggdrr', g_key=1).json()\\n assert response[\\\"status\\\"] != \\\"200 OK\\\"\",\n \"def get(self, request):\\n return Response(services.get_gsa_locations(request.query_params, request.META['HTTP_JWT']))\",\n \"def get_map_josn(request):\\n if request.method == 'GET':\\n data = get_json()\\n print('Responsed')\\n return Response(data,status=status.HTTP_200_OK)\",\n \"def results_gis_google(request, assessment_id):\\n try:\\n person = get_person(request)\\n # try:\\n # get the latest assessment from the city.\\n if assessment_id:\\n assessment = Assessment.objects.get(id=assessment_id)\\n else:\\n assessment = Assessment.objects.order_by('-date_started')[0]\\n # except:\\n # raise Exception('The City does not have any open assessment')\\n template = loader.get_template(TEMPLATE_RESULTS_GIS_GOOGLE)\\n\\n context = RequestContext(request, {\\n 'person': person,\\n 'assessment': assessment,\\n 'selected_main': \\\"RESULTS_GIS\\\",\\n 'selected_detail': \\\"RESULTS_GIS_GOOGLE\\\",\\n })\\n return HttpResponse(template.render(context))\\n except:\\n if debug_is_on():\\n raise\\n else:\\n return render_to_response(TEMPLATE_ERROR,\\n {\\\"error_description\\\": sys.exc_info(), \\\"crpt_url\\\": CRPT_URL},\\n context_instance=RequestContext(request))\",\n \"def setUp(self):\\n self.response = self.client.get('/map/')\",\n \"def test_geocode(self):\\n # get the minerva user's public folder\\n params = {\\n 'parentType': 'user',\\n 'parentId': self._user['_id'],\\n 'text': 'public'\\n }\\n response = self.request(\\n path='/folder',\\n method='GET',\\n params=params,\\n user=self._user\\n )\\n self.assertStatusOk(response)\\n user_folder = response.json[0]\\n\\n with mock.patch.object(urllib, 'urlretrieve', download_data):\\n # attempt to import as a regular user\\n response = self.request(\\n path='/geonames/setup',\\n method='POST',\\n params={\\n 'folder': user_folder['_id']\\n },\\n user=self._user\\n )\\n self.assertStatus(response, 403)\\n\\n # import the database\\n response = self.request(\\n path='/geonames/setup',\\n method='POST',\\n params={\\n 'folder': user_folder['_id']\\n },\\n user=self._admin\\n )\\n self.assertStatusOk(response)\\n\\n # set the geonames folder\\n response = self.request(\\n path='/system/setting',\\n method='PUT',\\n params={\\n 'key': 'minerva.geonames_folder',\\n 'value': user_folder['_id']\\n },\\n user=self._admin\\n )\\n self.assertStatusOk(response)\\n\\n # hit the geocoding endpoint\\n response = self.request(\\n path='/geonames/geocode',\\n params={\\n 'name': '\\\"little sheep mountain\\\"'\\n },\\n user=self._user\\n )\\n self.assertStatusOk(response)\\n\\n # check the response\\n self.assertEqual(\\n len(response.json['features']),\\n 1\\n )\\n self.assertEqual(\\n response.json['features'][0]['id'],\\n 5428978 # geonameid\\n )\",\n \"def get_data(query):\\n par = {\\\"key\\\": str(GOOGLE_KEY), \\\"query\\\": query}\\n url = \\\"https://maps.googleapis.com/maps/api/place/textsearch/json\\\"\\n req = requests.get(url, params=par)\\n return req.json()\",\n \"def placeToRoad(placeName):\\n # sleep(2)\\n g = gmaps.geocode(placeName)\\n roadNo, roadName = '', ''\\n zipCode, coor_Lat, coor_Lng = None, None, None\\n if len(g) > 0:\\n for ac in g[0]['address_components']:\\n if ac['types'] and len(ac['types']) > 0:\\n if ac['types'][0] == 'street_number':\\n try:\\n roadNo = ac['long_name']\\n except:\\n roadNo = ''\\n if ac['types'][0] == 'route':\\n try:\\n roadName = ac['long_name']\\n except:\\n roadName = ''\\n if ac['types'][0] == 'postal_code':\\n try:\\n zipCode = ac['long_name']\\n except:\\n zipCode = None\\n\\n # if 'long_name' in g[0]['address_components'][0].keys(): # road no.\\n # if g[0]['address_components'][0]['types'][0] == 'street_number':\\n # try:\\n # roadNo = g[0]['address_components'][0]['long_name']\\n # except:\\n # roadNo = ''\\n #\\n # if 'long_name' in g[0]['address_components'][1].keys(): # road name\\n # if g[0]['address_components'][1]['types'][0] == 'route':\\n # try:\\n # roadName = g[0]['address_components'][1]['long_name']\\n # except:\\n # roadName = ''\\n #\\n # if 'long_name' in g[0]['address_components'][-1].keys(): # zip code\\n # if g[0]['address_components'][-1]['types'][0] == 'postal_code':\\n # try:\\n # zipCode = g[0]['address_components'][-1]['long_name']\\n # except:\\n # zipCode = None\\n\\n if 'location' in g[0]['geometry'].keys():\\n try:\\n coor = g[0]['geometry']['location'] # APPROXIMATE location\\n coor_Lat = coor['lat']\\n coor_Lng = coor['lng']\\n except:\\n coor_Lat, coor_Lng = None, None\\n\\n roadName = roadNo + ' ' + roadName\\n coor = (coor_Lat, coor_Lng)\\n return roadName, zipCode, coor\",\n \"def api_call():\\n\\tresponse = requests.get(URL_API)\\n\\treturn response\",\n \"def setup_platform(hass, config, add_devices, discovery_info=None):\\n name = config.get(CONF_NAME)\\n api_key = config.get(CONF_API_KEY)\\n origin = config.get(CONF_ORIGIN)\\n options = config.get(CONF_OPTIONS)\\n display_zone = config.get(CONF_DISPLAY_ZONE)\\n\\n add_devices([GoogleGeocode(hass, origin, name, api_key, options, display_zone)])\",\n \"def lookup_lat_lon(location_string):\\n google_api_key = \\\"AIzaSyDAJxRxTE-ZC5M7qGN5Bg_FXwgc5e_TqdU\\\" \\n \\n\\n base = \\\"https://maps.googleapis.com/maps/api/geocode/json?address=\\\"\\n \\n return base + location_string + \\\"&key=\\\" + google_api_key\",\n \"def getting_location_key(latitude, longitude):\\n\\n API_Key = \\\"zIGuOeUd0aE4O621Gj1KGDc6JiZ3PAGb\\\"\\n http_request = f\\\"http://dataservice.accuweather.com/locations/v1/cities/geoposition/search?apikey={API_Key}&q={latitude}%2C%20{longitude}&language=pt-br\\\"\\n\\n location_key_request = requests.get(http_request)\\n\\n if location_key_request.status_code != 200:\\n print(\\\"It was not possible to retrive your location key. Please, try again later!!\\\")\\n exit()\\n\\n else:\\n location_key_response = location_key_request.json()\\n\\n location_key = location_key_response['Key']\\n \\n # EXTRACTING LOCATION INFORMATION --\\n country = location_key_response['Country']['LocalizedName']\\n state = location_key_response['AdministrativeArea']['ID']\\n city = location_key_response['ParentCity']['LocalizedName']\\n neighbourhood = location_key_response['LocalizedName']\\n\\n # PRINTING LOCATION INFORMATION --\\n title_printer(\\\" ---- LOCATION ----\\\")\\n time.sleep(0.5)\\n\\n print(\\\"Country\\\", end=\\\"\\\")\\n print(f\\\"{country:.>73}\\\")\\n time.sleep(0.5)\\n\\n print(\\\"State\\\", end=\\\"\\\")\\n print(f\\\"{state:.>75}\\\")\\n time.sleep(0.5)\\n\\n print(\\\"City\\\", end=\\\"\\\")\\n print(f\\\"{city:.>76}\\\")\\n time.sleep(0.5)\\n\\n print(\\\"Region\\\", end=\\\"\\\")\\n print(f\\\"{neighbourhood:.>74}\\\")\\n time.sleep(0.5)\\n\\n return location_key\",\n \"def driving():\\r\\n name = request.args[\\\"address\\\"]\\r\\n end_name=request.args[\\\"end_point\\\"]\\r\\n end_lng = request.args[\\\"end_lng\\\"]\\r\\n end_lat = request.args[\\\"end_lat\\\"]\\r\\n end_lng = float(end_lng)\\r\\n end_lat = float(end_lat)\\r\\n start_lng=get_address(name)[1]\\r\\n start_lat=get_address(name)[0]\\r\\n\\r\\n\\r\\n #get coordinates of start and end point\\r\\n map_directions, geojson_str = get_driving_map(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n logging.warning(\\\"Map directions %s\\\", str(map_directions))\\r\\n\\r\\n\\r\\n #retrieve instructions\\r\\n instructions = get_driving_instructions(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n\\r\\n\\r\\n # generate interactive map\\r\\n return render_template(\\r\\n \\\"page4.html\\\",\\r\\n mapbox_token=MAPBOX_TOKEN,\\r\\n geojson_str=geojson_str,\\r\\n end_name=end_name,\\r\\n name=name,\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lng,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n center_lng=(start_lng + end_lng) / 2,\\r\\n center_lat=(start_lat + end_lat) / 2,\\r\\n instructions=instructions,\\r\\n method = 'Driving'\\r\\n )\",\n \"def getGeo(self):\\n command = f'curl -s -m 5 http://ip-api.com/json/' + self.ip\\n result = subprocess.run(command.split(), capture_output=True)\\n data = result.stdout.decode(\\\"utf-8\\\").replace('\\\\n','')\\n try:\\n data = json.loads(data)\\n except json.decoder.JSONDecodeError:\\n # Error from ip-api.com\\n data = None\\n if data:\\n # {\\\"status\\\":\\\"success\\\",\\\"country\\\":\\\"Yemen\\\",\\\"countryCode\\\":\\\"YE\\\",\\\"region\\\":\\\"SA\\\",\\\"regionName\\\":\\\"Amanat Alasimah\\\",\\\"city\\\":\\\"Sanaa\\\",\\\"zip\\\":\\\"\\\",\\\"lat\\\":15.3522,\\\"lon\\\":44.2095,\\\"timezone\\\":\\\"Asia/Aden\\\",\\\"isp\\\":\\\"Public Telecommunication Corporation\\\",\\\"org\\\":\\\"YemenNet\\\",\\\"as\\\":\\\"AS30873 Public Telecommunication Corporation\\\",\\\"query\\\":\\\"134.35.218.63\\\"}\\n self.geodata = data\\n else:\\n self.geodata = None\",\n \"def fetchGeoData():\\n if request.method ==\\\"POST\\\":\\n result = {}\\n if request.get_json():\\n post_requests = request.get_json()\\n print(post_requests)\\n result = db.getmapdata(post_requests['attr']) \\n return result\",\n \"def geocoding(address, API_KEY=API_KEY, GEOCODE_API_URL=GEOCODE_API_URL):\\n # define the parameters of the search\\n params = {\\n 'address': '{}'.format(address),\\n 'key': API_KEY\\n }\\n\\n # Do the request and get the response data\\n response = requests.get(GEOCODE_API_URL, params=params)\\n response = response.json()\\n\\n geodata = parse_response(response)\\n return geodata\",\n \"def geoprocess(data, retry=None):\\n host = settings.GEOP['host']\\n port = settings.GEOP['port']\\n\\n geop_url = 'http://{}:{}/run'.format(host, port)\\n\\n try:\\n response = requests.post(geop_url,\\n data=json.dumps(data),\\n headers={'Content-Type': 'application/json'})\\n except ConnectionError as exc:\\n if retry is not None:\\n retry(exc=exc)\\n\\n if response.ok:\\n return response.json()['result']\\n else:\\n raise Exception('Geoprocessing Error.\\\\n'\\n 'Details: {}'.format(response.text))\",\n \"def request_directions(start_location, end_location):\\n now = datetime.datetime.now()\\n directions_response = GMAPS.directions(start_location, end_location,\\n mode=\\\"walking\\\", departure_time=now)\\n parsed_directions_response = parse_directions_response(directions_response)\\n return parsed_directions_response\",\n \"def test_list_maps(self):\\n res = self.client.get('/list_maps', follow_redirects=True)\\n self.assertEqual(res.status_code, 200)\\n\\n self._create_map_sc()\\n\\n \\\"\\\"\\\"Testing with one map saved into database\\\"\\\"\\\"\\n res = self.client.get('/list_maps', follow_redirects=True)\\n self.assertEqual(res.status_code, 200)\",\n \"def _check_api_key(self):\\n try:\\n self.maps.places_nearby(\\n location=(53.909804, 27.580184),\\n radius=650,\\n open_now=False,\\n language=config.LANGUAGE,\\n type='cafe',\\n # rank_by='distance', # IMPORTANT: cannot use rank_by and radius options together\\n page_token=None,\\n )\\n except Exception as e:\\n\\n with self.__writelock:\\n self.print(f'ERROR: bad API key \\\"{self.maps.key}\\\" (tracker={self.stats.previous_requests})\\\\n')\\n raise e\",\n \"def get(self):\\n street = self.request.args.get(\\\"street\\\", \\\"\\\")\\n zip = self.request.args.get(\\\"zip\\\",\\\"\\\")\\n city = self.request.args.get(\\\"city\\\",\\\"\\\")\\n country = self.request.args.get(\\\"country\\\",\\\"Germany\\\")\\n\\n if street==\\\"\\\" or city==\\\"\\\" or country==\\\"\\\":\\n return {'success': False, \\n 'msg': self._(\\\"no full address was given\\\")\\n }\\n try:\\n lat, lng = self.retrieve_location(street, zip, city, country)\\n except LocationNotFound:\\n return {'success': False, \\n 'msg': self._(\\\"we couldn't lookup a geo coordinates for this address\\\")\\n }\\n return {\\n 'success' : True,\\n 'lat' : lat,\\n 'lng' : lng\\n }\",\n \"def draw_map(self):\\n\\n polygon_lats, polygon_longs = self.get_polygon_coordinates()\\n car_route = self.get_car_route()\\n\\n polygon = self.construct_polygon(polygon_lats, polygon_longs)\\n\\n map_path = f'{self.result_path}/map_{self.postfix}.html'\\n\\n self.plot_map(df=car_route,\\n polygon=polygon,\\n lat_col='lat',\\n lon_col='long',\\n plot_points=True,\\n plot_polygon=True,\\n plot_heatmap=True,\\n file_name=map_path)\",\n \"def post(self):\\n data = json.dumps(request.get_json())\\n houseNumber = json.loads(data)['HouseNumber']\\n street = json.loads(data)['Street']\\n city = json.loads(data)['city']\\n #address = '&housenumber='+houseNumber+'&street='+street+'&city='+city\\n response = hereService.getLatLang(houseNumber, street, city)\\n return response\",\n \"def visualize(g):\\n url = \\\"http://www.gcmap.com/mapui?P=\\\"\\n routes = []\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n route = (g.city_dict[key].get_code(), flight[0])\\n if(route not in routes):\\n routes.append(route)\\n \\n for flight in routes:\\n url = url + flight[0] + \\\"-\\\" + flight[1]\\n url = url + \\\",+\\\"\\n \\n url = url[:-2]\\n return url\",\n \"def call(self):\\n\\n self.url = self._prepare_url()\\n status_code, response = self._do_request(self.url)\\n return self._process_response(status_code, response)\",\n \"def async_set_geocoding(provider, tracking_id=None, event_id=None):\\n loop = asyncio.get_event_loop()\\n loop.run_in\",\n \"def _sendRequest(lat, lng):\\n r = requests.get(\\n 'https://api.forecast.io/forecast/' +\\n _forecastApiKey +\\n '/' + lat +\\n ',' + lng +\\n '?units=us'\\n )\\n\\n data = r.json()\\n return data\",\n \"def test_map_details(self):\\n\\t\\tcreate_cartography()\\n\\t\\tmap = Map.objects.get(id=1)\\n\\t\\tc = Client()\\n\\t\\tresponse = c.get(\\\"/maps/%s\\\" % str(map.id))\\n\\t\\tself.assertEquals(response.status_code, 200)\",\n \"async def google(self, ctx, *, query: str=None):\\n # Handle no query being provided\\n if query is None:\\n return await ctx.error('Please provide a query!')\\n\\n # 'google_embed' is dependent on a test that checks whether google has embedded any external data on the page\\n # 'result_nums' is the no. of results to display when there is no embedded data\\n google_embed = False\\n params = {'q': quote_plus(query), 'source': 'hp'}\\n results_num = 3\\n\\n # Tries its best to imitate a real browser visit, an old user-agent is used to make scraping easier\\n async with self.aiohttp_session.get(self.url, params=params, headers=self.headers) as r:\\n html = await r.text()\\n\\n # Beautiful soup\\n soup = BeautifulSoup(html, 'lxml')\\n\\n # Get links and their brief descriptions, only upto 4 are taken at a time, it should've been three, but\\n # if you read the code, it tries to work around an extra entry that is just 'Images for '.\\n # URLs on google search are redirected through 'google.com/url?url=xxxxx' , this uses cgi and urlparse to\\n # grab only the 'url' URL parameter and get rid of the other parameters google passes for logging etc to\\n # 'google.com/url'\\n result_links = [parse_qs(urlparse(x.attrs['href'])[4])['url'][0] for x in soup.select('div.g h3.r a')[:4] if\\n '/search' not in x.attrs['href'] and not x.text == '']\\n result_desc = [x.text for x in soup.select('div#ires div.g div.s span.st')[:4] if\\n '/search' not in x.text and not x.text == '']\\n\\n # 'hp-xpdbox' is the class for google's embedded data, if this exists, google_embed is changed to True\\n # and results are changed to 2\\n if soup.select('div.hp-xpdbox div._tXc'):\\n google_embed = True\\n embed_title = [a.text for a in soup.select('div._B5d')][0]\\n try:\\n embed_type = [a.text for a in soup.select('div._Pxg')][0]\\n except IndexError:\\n embed_type = None\\n embed_details = [a.text for a in soup.select('div._tXc span')][0]\\n results_num -= 1\\n\\n # Embedded data might not always have an image, this works around that\\n img = None\\n try:\\n img = [img.attrs.get('src') for img in soup.select('div._i8d img')][0]\\n except IndexError:\\n pass\\n\\n # Create embed if google_embed is true\\n if google_embed:\\n msg = f\\\"**{embed_title}**\\\"\\n if embed_type is not None:\\n msg += f\\\" ({embed_type})\\\"\\n msg += f\\\"\\\\n\\\\n{embed_details}\\\\n\\\"\\n if img:\\n msg += f\\\"**Image:**\\\\n{img}\\\"\\n\\n results = \\\"\\\\n\\\\n\\\".join([f'<{link}>\\\\n{desc}' for link, desc in list(zip(result_links, result_desc))[:results_num]])\\n\\n if google_embed:\\n await ctx.message.edit(content=f\\\"**Results for {query}:**\\\\n{results}\\\\n\\\\n{msg}\\\")\\n else:\\n await ctx.message.edit(content=f\\\"**Results for {query}:**\\\\n{results}\\\")\",\n \"def GetLocation(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def Greenland_map(service='ESRI_Imagery_World_2D', epsg=3413, xpixels=5000):\\n m = Basemap(projection='npstere', boundinglat=70, lon_0=315, epsg=epsg, llcrnrlon=300, llcrnrlat=57, urcrnrlon=20, urcrnrlat=80, resolution='h')\\n \\n plt.figure()\\n m.arcgisimage(service=service, xpixels=xpixels)\\n plt.show()\\n return m\",\n \"def reverse_geocoding(lat, lng, API_KEY=API_KEY, GEOCODE_API_URL=GEOCODE_API_URL):\\n params = {\\n 'latlng': '{},{}'.format(lat, lng),\\n 'key': API_KEY\\n }\\n\\n # Do the request and get the response data\\n response = requests.get(GEOCODE_API_URL, params=params)\\n response = response.json()\\n geodata = parse_response(response)\\n return geodata\",\n \"def build_maps():\\n return render_template(\\\"maps.html\\\")\",\n \"def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\\n width, height = 256 * wTileN, 256 * hTileN\\n map_img = Image.new('RGB', (width, height))\\n for x in range(0, wTileN):\\n for y in range(0, hTileN):\\n url = 'https://mt0.google.com/vt?x=' + \\\\\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\\n current_tile = str(x)+'-'+str(y)\\n urllib.request.urlretrieve(url, current_tile)\\n map_img.paste(Image.open(current_tile), (x*256, y*256))\\n os.remove(current_tile)\\n return map_img\",\n \"def run(self):\\n while not self.setup() and self.running:\\n pass\\n\\n while self.running:\\n # Create a byte array to receive the computed maps\\n mapb = bytearray(self.MAP_SIZE_PIXELS * self.MAP_SIZE_PIXELS)\\n\\n # Get final map \\n self.slam.getmap(mapb)\\n try:\\n self.connection.send(mapb)\\n except socket.error:\\n print \\\"MapServer: Client disconnected\\\"\\n if self.running:\\n self.setup()\",\n \"def makeAddressToGeocodeRequest(address):\\n global headersGlobal, URL_addressToGeocode # get global variables\\n\\n key = variables.bingMapsAPIKey # api key\\n\\n # construct the url\\n url = URL_addressToGeocode + str(address[0]) + \\\"/\\\" + str(address[1]) + \\\"/\\\" + str(address[2]) + \\\"/\\\" + str(\\n address[3]) + \\\"/\\\" + str(address[4]) + \\\"?key=\\\" + key\\n\\n request = requests.get(url, headers=headersGlobal) # make the request\\n return request # return the request\",\n \"def main():\\n\\n creds = None\\n # The file token.json stores the user's access and refresh tokens, and is\\n # created automatically when the authorization flow completes for the first\\n # time.\\n\\n # There was no need to do this with Google Sheets... I just felt like being extra.\\n if os.path.exists('token.json'):\\n creds = Credentials.from_authorized_user_file('token.json', SCOPES)\\n # If there are no (valid) credentials available, let the user log in.\\n if not creds or not creds.valid:\\n if creds and creds.expired and creds.refresh_token:\\n creds.refresh(Request())\\n else:\\n flow = InstalledAppFlow.from_client_secrets_file(\\n 'credentials.json', SCOPES)\\n creds = flow.run_local_server(port=0)\\n # Save the credentials for the next run\\n with open('token.json', 'w') as token:\\n token.write(creds.to_json())\\n\\n service = build('sheets', 'v4', credentials=creds)\\n\\n # Call the Sheets API\\n sheet = service.spreadsheets()\\n map_df = pd.read_csv('data/rel_map.csv')\\n \\n for i, rows in map_df.iterrows():\\n print(rows.show_season, rows.lead)\\n first_url = rows.show_season\\n write_from_URL(wiki_head + first_url, sheet, rows.lead, rows.show_season)\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # google_maps_destination\\n # google_maps_origin\\n # Message Destinations:\\n # fn_google_maps_directions\\n # Functions:\\n # fn_google_maps_directions\\n # Workflows:\\n # example_google_maps_directions\\n # Rules:\\n # Get Directions\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nLCAiZXhwb3J0X2RhdGUiOiAxNTM5ODY3NjgwMjk5fQ==\\n\\\"\\\"\\\"\\n )\",\n \"def runAnalytics():\\n #gets OAuth from the API\\n analytics = get_Analytics_service()\\n #get the object return from the API\\n #send that object to print out useful fields\\n response = get_report(analytics)\\n print_response(response)\",\n \"def main():\\n ip_obj = get_ip()\\n url = (\\\"http://ipvigilante.com/\\\" + ip_obj.ip_address + \\\"/full\\\")\\n response = urlopen(url)\\n data_json = response.read().decode(\\\"utf-8\\\")\\n geoloc = json.loads(data_json)\\n\\n # print(geoloc)\\n print(\\\"ipv4: \\\", geoloc['data']['ipv4'])\\n print(\\\"hostname: \\\", geoloc['data']['hostname'])\\n print(\\\"continent_code: \\\", geoloc['data']['continent_code'])\\n print(\\\"continent_name: \\\", geoloc['data']['continent_name'])\\n print(\\\"country_iso_code: \\\", geoloc['data']['country_iso_code'])\\n print(\\\"country_name: \\\", geoloc['data']['country_name'])\\n print(\\\"subdivision_1_iso_code: \\\", geoloc['data']['subdivision_1_iso_code'])\\n print(\\\"subdivision_1_name: \\\", geoloc['data']['subdivision_1_name'])\\n print(\\\"subdivision_2_iso_code: \\\", geoloc['data']['subdivision_2_iso_code'])\\n print(\\\"subdivision_2_name: \\\", geoloc['data']['subdivision_2_name'])\\n print(\\\"city_name: \\\", geoloc['data']['city_name'])\\n print(\\\"metro_code: \\\", geoloc['data']['metro_code'])\\n print(\\\"time_zone: \\\", geoloc['data']['time_zone'])\\n print(\\\"postal_code: \\\", geoloc['data']['postal_code'])\\n print(\\\"latitude: \\\", geoloc['data']['latitude'])\\n print(\\\"longitude: \\\", geoloc['data']['longitude'])\\n print(\\\"accuracy_radius: \\\", geoloc['data']['accuracy_radius'])\",\n \"def geocube():\",\n \"def __init__(self, lat, lon, grid, api):\\n self.lat = lat\\n self.lon = lon\\n self.city = grid['city']\\n self.county = grid['county']\\n self.village = grid['village']\\n self.api = api\\n self.result = {}\",\n \"def setUp(self):\\n SetUp.setUp()\\n self.response = self.client.get('/map/')\",\n \"def google(self, input):\\n\\n args = input.args or \\\"\\\"\\n parser = self.OptionParser()\\n parser.add_option(\\\"-d\\\", \\\"-r\\\", \\\"--results\\\", dest=\\\"results\\\", default=1, type=\\\"int\\\")\\n (options, args) = parser.parse_args(args.split())\\n if not args:\\n raise self.BadInputError()\\n query = \\\" \\\".join(args).encode('utf-8')\\n\\n if options.results < 1:\\n options.results = 1\\n elif options.results > 10:\\n options.results = 10\\n\\n try:\\n data = urllib.urlopen('http://www.google.com/uds/GwebSearch?callback=GwebSearch.RawCompletion&context=0&lstkp=0&hl=en&key=ABQIAAAAeBvxXUmueP_8_kTINo0H4hSKL4HoBFFxfS_vfvgFpLqAt5GPWRTHDAESci2RYvZRkcpsYXapXjZWKA&v=1.0&rsz=large&q=%s' % urllib.quote(query)).read()\\n except IOError: \\n self.say(\\\"Error: Unable to establish a connection to google.com\\\")\\n return\\n data = unescapeuni(data)\\n data = decodehtml(data)\\n\\n m = re.search('estimatedResultCount\\\":\\\"([^\\\"]+)\\\"', data)\\n if m:\\n matches = m.group(1)\\n m = re.findall(r'\\\"url\\\":\\\"([^\\\"]*)\\\".*?\\\"titleNoFormatting\\\":\\\"([^\\\"]*)\\\",\\\"content\\\":\\\"([^\\\"]*)\\\"', data, re.IGNORECASE)\\n if m:\\n if len(m) < options.results:\\n options.results = len(m)\\n if options.results == 1:\\n self.say('\\\\x02%s\\\\x02 - ( \\\\x1f%s\\\\x1f ) [%s matches]' % (removehtml(m[0][1]), urllib.unquote(m[0][0]), matches))\\n self.say(removehtml(m[0][2]))\\n else:\\n self.say('Showing the first \\\\x02%s\\\\x02 of \\\\x02%s\\\\x02 matches' % (options.results, matches))\\n for x in range(options.results):\\n self.say('\\\\x02%s\\\\x02 - ( \\\\x1f%s\\\\x1f )' % (removehtml(m[x][1]), urllib.unquote(m[x][0])))\\n\\n else:\\n self.say('Your search for \\\\x02%s\\\\x02 did not return any results.' % input.args)\",\n \"def do_gga_location(self,data):\\n global location\\n\\n d = data.split(',')\\n location['type'] = 'GGA'\\n location['lat'] = \\\"%s%s\\\" % (d[1],d[2])\\n location['long'] = \\\"%s%s\\\" % (d[3],d[4])\\n location['alt'] = \\\"%s %s\\\" % (d[8],d[9])\\n location['time'] = self.format_time(d[0])\\n location['sats'] = d[7]\",\n \"def __init__(self, api_key=None, secret_key=None, headers=None):\\n # set up base requester\\n self._base_requester = Requester(API_ENDPOINT, api_key=api_key, secret_key=secret_key, headers=headers)\\n # add each endpoint\\n self.geocode = self.Geocode(self._base_requester)\\n self.places = self.Places(self._base_requester)\",\n \"def _onbuttonReqMapClicked(self):\\n\\n day1=str(self.combo_wms_time_first_d.currentText())\\n hour1=str(self.combo_wms_time_first_h.currentText())\\n date_val=day1+hour1\\n depth=str(self.combo_wms_layer_depth.currentText())\\n variable=str(self.combo_variable_list.currentText())\\n product=str(self.combo_product_list.currentText())\\n dataset=str(self.combo_dataset_list.currentText())\\n xmin=int(float(self.WMS_westBound.text()))\\n xmax=int(float(self.WMS_eastBound.text()))\\n ymin=int(float(self.WMS_southBound.text()))\\n ymax=int(float(self.WMS_northBound.text()))\\n dir_out=self.tmp\\n rastermin=self.minscale_value.text()\\n rastermax=self.maxscale_value.text()\\n nb_colors=self.nbcolors_value.text()\\n xpixels=float(self.Xpixels_value.text())\\n xparallels=int(self.Xparallels_value.text())\\n ymeridians=int(self.Ymedians_value.text())\\n dpi=300\\n colorbar=str(self.combo_colorbar.currentText())\\n input_srs=str(self.combo_proj.currentText())\\n epsg_val=input_srs.split(':')[1]\\n ll_polar=False\\n##\\tif self.checkBox_2.isChecked() == True :\\n##\\t print \\\"Projection arctic\\\"\\n## #m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\\n## # urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \\n## ##m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \\n## m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \\n## #Proj4js.defs[\\\"EPSG:3408\\\"] = \\\"+proj=laea +lat_0=90 +lon_0=0 +x_0=0 +y_0=0 +a=6371228 +b=6371228 +units=m +no_defs\\\";\\n## #\\n## ll_polar=True\\n##\\telif self.checkBox_3.isChecked() == True :\\n##\\t print \\\"Projection antarctic\\\"\\n## m = Basemap(projection='spstere',boundinglat=ymax,lon_0=180,round=True,resolution='l') \\n## ll_polar=True\\n##\\telse : \\n m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\\n urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \\n print \\\"cylindric projection\\\"\\n\\n # ypixels not given, find by scaling xpixels by the map aspect ratio.\\n ypixels = int(m.aspect*xpixels)\\n style='boxfill/'+colorbar\\n print input_srs\\n print epsg_val\\n p = pyproj.Proj(init=\\\"epsg:%s\\\" % epsg_val, preserve_units=True)\\n xmin,ymin = p(m.llcrnrlon,m.llcrnrlat)\\n xmax,ymax = p(m.urcrnrlon,m.urcrnrlat)\\n if epsg_val == '4326' :\\n xmin = (180./np.pi)*xmin; xmax = (180./np.pi)*xmax\\n ymin = (180./np.pi)*ymin; ymax = (180./np.pi)*ymax\\n print \\\"Cylindric projection\\\"\\n print xmin,xmax,ymin,ymax\\n print style\\n img = self.wms.getmap(layers=[variable],service='wms',bbox=(xmin,ymin,xmax,ymax),\\n size=(int(xpixels),ypixels),\\n format='image/png',\\n elevation=depth,\\n srs=input_srs,\\n time=date_val,\\n colorscalerange=rastermin+','+rastermax,numcolorbands=nb_colors,logscale=False,\\n styles=[style])\\n image=imread(io.BytesIO(img.read()),format='png')\\n if variable == \\\"sea_water_velocity\\\" :\\n ylabel=\\\"magnitude\\\"\\n else :\\n ylabel=self.wms[variable].abstract\\n\\n long_name=self.wms[variable].title\\n title=product+\\\" - \\\"+long_name+\\\" \\\"+\\\" - \\\"+date_val\\n file_pal='./palettes/thredds/'+colorbar+'.pal'\\n my_cmap=compute_cmap(file_pal,colorbar)\\n cm.register_cmap(name=colorbar, cmap=my_cmap)\\n font=10\\n norm = mpl.colors.Normalize(vmin=float(rastermin), vmax=float(rastermax), clip=False) \\n parallels=np.round(np.arange(ymin,ymax+xparallels/2,xparallels))\\n meridians = np.round(np.arange(xmin,xmax+ymeridians/2,ymeridians))\\n # Plot figure \\n plt.figure(figsize=(20,12))\\n if epsg_val == '4326' :\\n m.drawcoastlines(color='lightgrey',linewidth=0.25)\\n m.fillcontinents(color='lightgrey')\\n m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\\n\\n elif ll_polar == True : \\n #m.drawcoastlines(linewidth=0.5)\\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\\n m.drawmeridians(meridians[:-1],labels=[1,1,1,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\\n ## Plot the image\\n cs=m.imshow(image,origin='upper',alpha=1,cmap=(cm.get_cmap(colorbar,int(nb_colors))),norm=norm)\\n ## Add colorbar\\n cb=plt.colorbar(cs,orientation='vertical',format='%4.2f',shrink=0.7)\\n cb.ax.set_ylabel(ylabel, fontsize=int(font)+4)\\n cl=plt.getp(cb.ax, 'ymajorticklabels')\\n plt.setp(cl, fontsize=font)\\n\\n plt.title(title,fontsize=font+4,y=1.05)\\n plt.savefig('images/'+product+\\\"_\\\"+long_name+\\\"_\\\"+date_val+\\\"_basemap.png\\\",dpi=300,bbox_inches='tight')\\n plt.show()\",\n \"def google(query, num_results=1):\\n\\tif not API_KEY:\\n\\t\\traise ConfigException(\\\"Require API_KEY for googleapi. Reload after setting.\\\")\\n\\td = { \\\"q\\\" : query.encode(\\\"utf-8\\\"), \\\"key\\\" : API_KEY, \\\"cx\\\" : CSE_ID, \\\"num\\\" : num_results,\\n\\t\\t\\\"fields\\\" : \\\"spelling/correctedQuery,items(title,link,snippet)\\\" }\\n\\t\\n\\tf = urlopen(SEARCH_URL % (urlencode(d)))\\n\\tgdata = load(f)\\n\\tif f.getcode() == 200:\\n\\t\\tresults = []\\n\\t\\tspelling = gdata.get(\\\"spelling\\\")\\n\\t\\tif spelling: spelling = spelling[\\\"correctedQuery\\\"]\\n\\t\\tif \\\"items\\\" in gdata:\\n\\t\\t\\tfor item in gdata[\\\"items\\\"]:\\n\\t\\t\\t\\tsnippet = item[\\\"snippet\\\"].replace(\\\" \\\\n\\\", \\\" \\\") if \\\"snippet\\\" in item else \\\"\\\"\\n\\t\\t\\t\\tresults.append((item[\\\"title\\\"], snippet, item[\\\"link\\\"]))\\n\\t\\treturn (spelling, results)\\n\\telse:\\n\\t\\traise RuntimeError(\\\"Error: %s\\\" % (gdata.replace(\\\"\\\\n\\\", \\\" \\\")))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6655652","0.64451903","0.6228928","0.6192054","0.61880857","0.60813564","0.5891248","0.58714527","0.5839972","0.5789041","0.57397115","0.57201695","0.5664012","0.5558423","0.55010176","0.5402953","0.5361477","0.5352793","0.5310342","0.5282193","0.5269215","0.5266978","0.52378625","0.52317286","0.52024275","0.518204","0.51450664","0.5144176","0.51224506","0.51048285","0.5100127","0.50933266","0.5089275","0.50862414","0.50203997","0.49796557","0.49751228","0.49749136","0.49740717","0.4963081","0.49464756","0.4899858","0.48843777","0.48663533","0.4859687","0.48432282","0.48405468","0.48318523","0.4823617","0.48176163","0.48106197","0.48083648","0.4805718","0.48043716","0.48026294","0.47964245","0.47911963","0.47851145","0.4783948","0.4774791","0.47722083","0.4765151","0.47618577","0.47475085","0.4728848","0.47236416","0.4721344","0.4715523","0.47082245","0.47061527","0.47031435","0.46964982","0.4695638","0.46950883","0.46796963","0.46795666","0.4665209","0.46614286","0.46584213","0.46547392","0.465448","0.46536574","0.46474677","0.4645079","0.46427467","0.4637031","0.46293065","0.46270812","0.46198544","0.461964","0.46154037","0.4608886","0.46071458","0.46029073","0.4597916","0.45911863","0.45865166","0.45861006","0.45819616","0.4581567","0.457959"],"string":"[\n \"0.6655652\",\n \"0.64451903\",\n \"0.6228928\",\n \"0.6192054\",\n \"0.61880857\",\n \"0.60813564\",\n \"0.5891248\",\n \"0.58714527\",\n \"0.5839972\",\n \"0.5789041\",\n \"0.57397115\",\n \"0.57201695\",\n \"0.5664012\",\n \"0.5558423\",\n \"0.55010176\",\n \"0.5402953\",\n \"0.5361477\",\n \"0.5352793\",\n \"0.5310342\",\n \"0.5282193\",\n \"0.5269215\",\n \"0.5266978\",\n \"0.52378625\",\n \"0.52317286\",\n \"0.52024275\",\n \"0.518204\",\n \"0.51450664\",\n \"0.5144176\",\n \"0.51224506\",\n \"0.51048285\",\n \"0.5100127\",\n \"0.50933266\",\n \"0.5089275\",\n \"0.50862414\",\n \"0.50203997\",\n \"0.49796557\",\n \"0.49751228\",\n \"0.49749136\",\n \"0.49740717\",\n \"0.4963081\",\n \"0.49464756\",\n \"0.4899858\",\n \"0.48843777\",\n \"0.48663533\",\n \"0.4859687\",\n \"0.48432282\",\n \"0.48405468\",\n \"0.48318523\",\n \"0.4823617\",\n \"0.48176163\",\n \"0.48106197\",\n \"0.48083648\",\n \"0.4805718\",\n \"0.48043716\",\n \"0.48026294\",\n \"0.47964245\",\n \"0.47911963\",\n \"0.47851145\",\n \"0.4783948\",\n \"0.4774791\",\n \"0.47722083\",\n \"0.4765151\",\n \"0.47618577\",\n \"0.47475085\",\n \"0.4728848\",\n \"0.47236416\",\n \"0.4721344\",\n \"0.4715523\",\n \"0.47082245\",\n \"0.47061527\",\n \"0.47031435\",\n \"0.46964982\",\n \"0.4695638\",\n \"0.46950883\",\n \"0.46796963\",\n \"0.46795666\",\n \"0.4665209\",\n \"0.46614286\",\n \"0.46584213\",\n \"0.46547392\",\n \"0.465448\",\n \"0.46536574\",\n \"0.46474677\",\n \"0.4645079\",\n \"0.46427467\",\n \"0.4637031\",\n \"0.46293065\",\n \"0.46270812\",\n \"0.46198544\",\n \"0.461964\",\n \"0.46154037\",\n \"0.4608886\",\n \"0.46071458\",\n \"0.46029073\",\n \"0.4597916\",\n \"0.45911863\",\n \"0.45865166\",\n \"0.45861006\",\n \"0.45819616\",\n \"0.4581567\",\n \"0.457959\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20179,"cells":{"query":{"kind":"string","value":"Takes advantage of html parser as google directions api returns instructions in html. So want to strip all html tags and just return text"},"document":{"kind":"string","value":"def find_directions(start, end, transit_mode=None):\n dir_url = build_url(start, end, transit_mode)[0]\n json_response = json.loads(urllib.request.urlopen(dir_url).read().decode('utf-8'))\n route_legs = json_response[routes_key][0][legs_key]\n directions = []\n for leg in route_legs:\n for step in leg[steps_key]:\n directions.append(strip_tags(step[instr_key]))\n\n return directions"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def remove_html( html):\n return html2txt(html)","def strip_html(text):\n soup = BeautifulSoup(text, \"html.parser\")\n return soup.get_text()","def strip_html(inputString):\r\n return BeautifulSoup(inputString, \"html.parser\").text","def strip_html_tags(text):\r\n soup = BeautifulSoup(text, 'lxml')\r\n stripped_text = soup.get_text(separator=\" \")\r\n return stripped_text","def remove_html(txt):\r\n TAG_RE = re.compile(r'<[^>]+>')\r\n return TAG_RE.sub(\"\", txt).strip()","def strip_html_tags(text):\n soup = BeautifulSoup(text, \"html.parser\")\n stripped_text = soup.get_text(separator=\" \")\n return stripped_text","def strip_html_tags(text):\n soup = BeautifulSoup(text, \"html.parser\")\n stripped_text = soup.get_text(separator=\" \")\n return stripped_text","def scrubHTML( html ):\n parser = StrippingParser()\n parser.feed( html )\n parser.close()\n return parser.result","def html_to_text(text):\n # type (str) -> str\n soup = BeautifulSoup(text, \"html.parser\")\n return \"\\n\".join(soup.stripped_strings)","def clean_html(html):\n html = re.sub(r\"(?s)<!--(.*?)-->[\\n]?\", \"\\\\1\", html)\n html = re.sub(r\"<!--\", \"\", html)\n if html == '':\n return ''\n s = MLStripper()\n s.feed(html)\n return s.get_data().strip()","def _strip_excerpt(self, raw_html):\n clean_regex = re.compile(\"<.*?>\")\n clean_text = re.sub(clean_regex, \"\", raw_html)\n return html.unescape(clean_text).replace(\"\\n\", \"\")","def remove_html_tags(text: str) -> str:\n return re.sub('<.*?>', '', text).strip()","def extract_page_text(html):\n soup = bs4.BeautifulSoup(html)\n\n # Remove <script/> and <style/> content\n for script in soup([\"script\", \"style\"]):\n script.extract()\n\n text = soup.get_text()\n\n # Strip leading and trailing whitespace from each line, then join all the\n # non-empty lines together.\n lines = (line.strip() for line in text.splitlines())\n text = '\\n'.join(line for line in lines if line)\n\n return text","def extract(content):\n parser = MyHTMLParser()\n parser.textBody = []\n parser.feed(content)\n textBody = parser.textBody\n textBody = \" \".join(textBody)\n textBody = textBody.replace('\\xa0', \" \")\n return textBody.strip()","def html_to_text(html):\n html_parser = 'html5lib'\n soup = BeautifulSoup(html, html_parser)\n pretty_html = soup.prettify()\n pretty_soup = BeautifulSoup(pretty_html, html_parser)\n text = pretty_soup.get_text()\n lines = [s for s in text.splitlines() if not re.search(r'^\\s*$', s)]\n return os.linesep.join(lines)","def strip_html(text: str, **serializer_kwargs: bool):\n cleaner = get_cleaner(**serializer_kwargs)\n text = cleaner.clean(text)\n return text","def remove_html_tags(html_text: str) -> str:\n document = fromstring(html_text)\n text = document.text_content()\n return text.strip()","def remove_html(text):\n return re.sub(r'<.*?>', r'', text)","def remove_html_tags(text):\n print('VOU REMOVER AS TAGS DA STRING')\n clean = re.compile('<.*?>')\n print('',re.sub(clean, '', text))\n return re.sub(clean, '', text)","def strip_tags(html):\n if html is None:\n html = ''\n s = MLStripper()\n s.feed(html)\n return s.get_data()","def strip_tags(self, html):\n s = MLStripper()\n s.feed(html)\n return s.get_data()","def _get_text(raw_html):\n bs = BeautifulSoup(raw_html)\n text_nodes = bs.find_all(_is_text_tag)\n text_elements = [_get_child_text(node) for node in text_nodes]\n return ' '.join(chain(*chain(*text_elements)))","def stripHtml(html):\n\t# kinda works\n\tres = html.replace(\"<\", \"<\")\n\tres = res.replace(\">\", \">\")\n\tres = re.sub(r'<[^>]+>', '', res)\n\treturn res","def text_from_html(body):\n soup = BeautifulSoup(body, \"html.parser\")\n texts = soup.findAll(text=True)\n visible_texts = filter(tag_visible, texts)\n return \" \".join(t.strip() for t in visible_texts)","def stripHTMLTags (html):\n text = html\n \n # apply rules in given order!\n rules = [\n { r'>\\s+' : u'>'}, # remove spaces after a tag opens or closes\n { r'\\s+' : u' '}, # replace consecutive spaces\n { r'\\s*<br\\s*/?>\\s*' : u'\\n'}, # newline after a <br>\n { r'</(div)\\s*>\\s*' : u'\\n'}, # newline after </p> and </div> and <h1/>...\n { r'</(p|h\\d)\\s*>\\s*' : u'\\n\\n'}, # newline after </p> and </div> and <h1/>...\n { r'<head>.*<\\s*(/head|body)[^>]*>' : u'' }, # remove <head> to </head>\n { r'<a\\s+href=\"([^\"]+)\"[^>]*>.*</a>' : r'\\1' }, # show links instead of texts\n { r'[ \\t]*<[^<]*?/?>' : u'' }, # remove remaining tags\n { r'^\\s+' : u'' } # remove spaces at the beginning\n ]\n \n for rule in rules:\n for (k,v) in rule.items():\n regex = re.compile (k)\n text = regex.sub (v, text)\n \n # replace special strings\n special = {\n ' ' : ' ', '&' : '&', '"' : '\"',\n '<' : '<', '>' : '>'\n }\n \n for (k,v) in special.items():\n text = text.replace (k, v)\n\n filtered = filter(lambda x: not re.match(r'^\\s*$', x), text) \n finaltext = re.sub(u'分享：','', filtered)\n return finaltext","def strip_html_tags(text):\n if text is np.nan:\n return text\n regex = re.compile(r\"<.*?>\")\n return re.sub(regex, \"\", text)","def extract_html(tag):\n s = unescape(remove_all_empty_tags(tag).renderContents())\n if type(s) != unicode:\n return s.decode('utf-8')\n return s","def remove_html_tags(self,text):\n #https://medium.com/@jorlugaqui/how-to-strip-html-tags-from-a-string-in-python-7cb81a2bbf44\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text)","def html_to_text(html):\n s = TextExtractorHTMLParser()\n s.feed(html)\n return s.get_text()","def extractText(text):\n soup = BeautifulSoup(text, 'html.parser')\n for code in soup.find_all('code'):\n code.decompose()\n return soup.get_text()","def strip_html(html_str):\n return bleach.clean(html_str, tags=[], attributes={},\n styles=[], strip=True)","def _html_text(self, html):\n ee = None\n try: return html.html_text()\n except Exception, e: ee = e; pass\n try: return html.xml_text()\n except Exception, e: print \"HtmlDocument/text\", ee, e; pass\n try: return str(html)\n except Exception, e: print \"HtmlDocument/text\", e; return \" \"","def extractText(postSoup):\n for tag in postSoup.findAll(True):\n if tag.name in (\"code\"):\n tag.extract()\n else:\n tag.hidden=True\n\n return postSoup.renderContents()","def get_text_hook(raw):\n soup = bs4.BeautifulSoup(quopri.decodestring(raw), features=\"lxml\")\n return soup.text","def extract_answer_from_html(self, html):\n if html.strip().startswith('<'):\n soup = bs4.BeautifulSoup(html, 'html.parser')\n\n for p in soup.find_all('p'):\n if self.REPLY_RE.match(p.text):\n for el in list(p.previous_elements):\n if isinstance(el, bs4.element.Tag):\n el.decompose()\n p.decompose()\n break\n\n return str(soup)\n else:\n # plain text\n match = self.REPLY_RE.search(html)\n if match:\n return html[match.end(0):]\n\n return html","def strip_html(unclean):\n # We make this noop for non-string, non-collection inputs so this function can be used with higher-order\n # functions, such as rapply (recursively applies a function to collections)\n if not isinstance(unclean, basestring) and not is_iterable(unclean) and unclean is not None:\n return unclean\n return bleach.clean(unclean, strip=True, tags=[], attributes=[], styles=[])","def text_from_html(soup):\n\n texts = soup.findAll(text=True)\n visible_texts = filter(tag_visible, texts)\n\n return u\" \".join(t.strip() for t in visible_texts)","def unhtmlify(html):\n return unescape(re.sub(r'<.*?>', '', html))","def stripHTMLTags (html):\r\n import re\r\n text = html\r\n \r\n # apply rules in given order!\r\n rules = [\r\n { r'>\\s+' : u'>'}, # remove spaces after a tag opens or closes\r\n { r'\\s+' : u' '}, # replace consecutive spaces\r\n { r'\\s*<br\\s*/?>\\s*' : u'\\n'}, # newline after a <br>\r\n #{ r'</(div)\\s*>\\s*' : u'\\n'}, # newline after </p> and </div> and <h1/>...\r\n #{ r'</(p|h\\d)\\s*>\\s*' : u'\\n\\n'}, # newline after </p> and </div> and <h1/>...\r\n { r'<head>.*<\\s*(/head|body)[^>]*>' : u'' }, # remove <head> to </head>\r\n { r'<a\\s+href=\"([^\"]+)\"[^>]*>.*</a>' : u'' }, # show links instead of texts\r\n { r'[ \\t]*<[^<]*?/?>' : u'' }, # remove remaining tags\r\n { r'^\\s+' : u'' } # remove spaces at the beginning\r\n ]\r\n \r\n for rule in rules:\r\n for (k,v) in rule.items():\r\n regex = re.compile (k)\r\n text = regex.sub (v, text)\r\n \r\n # replace special strings\r\n special = {\r\n ' ' : ' ', '&' : '&', '"' : '\"',\r\n '<' : '<', '>' : '>'\r\n }\r\n \r\n for (k,v) in special.items():\r\n text = text.replace (k, v)\r\n \r\n return text","def strip_markup(text):\n html_tag_regex = re.compile(\n r'<'\n r'[(--)\\?\\!\\%\\/]?'\n r'[a-zA-Z0-9#\\\"\\=\\s\\.\\;\\:\\%\\&?!,\\+\\*\\-_\\/]+'\n r'\\/?>',\n re.MULTILINE | re.UNICODE\n )\n if text:\n text = re.sub(html_tag_regex, ' ', text)\n return text","def strip_tags(text):\n # Remove header tags\n p = re.compile(\"<\\?.+?\\?>\") \n text = re.sub(p, \"\", text)\n\n # Remove <HOO>, <p> and <s> tags\n text = text.replace(\"<p>\",\"\")\n text = text.replace(\"</p>\",\"\")\n text = text.replace(\"<s>\",\"\")\n text = text.replace(\"</s>\",\"\")\n text = text.replace(\"<HOO>\",\"\")\n text = text.replace(\"</HOO>\",\"\")\n\n return text","def strip_tags_from_html(html):\n\n tag_re = re_compile(r'(<!--.*?-->|<[^>]*>)')\n return tag_re.sub('', html)","def clean_html(soup):\n html = str(soup.findAll('p', text=True)).strip()\n tags = re.compile('<.*?>')\n clean_2 = re.sub(tags, '', html)\n line_removed = clean_2.replace('\\n', ' ').replace('\\r', '').replace('’', ' ')\n return re.sub(r\"[-()\\\"#”/@“—;:<>{}'`+=~|!?,]\", \"\", line_removed).strip()","def parsed_html_lean():\n return utils.parse_html(\n \"\"\"\n <!doctype hmtl>\n <html>\n <head>\n <title>Page title</title>\n </head>\n <body>\n <h1>Django Auto AMP</h1>\n <p>Generate automatic AMP from your Django templates</p>\n </body>\n </html>\n \"\"\"\n )","def clean_html(text):\n cleanr = re.compile(\"<.*?>\")\n clean_text = re.sub(cleanr, \"\", text)\n return clean_text","def remove_html_tags_fun(self):\n cleaner = re.compile('<.*?>')\n cleaned_text = re.sub(cleaner, '', self.doc)\n cleaned_text = re.sub('[\\n\\t]', '', cleaned_text)\n self.doc = cleaned_text","def remove_html_tags(text):\n import re\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text).rstrip('...')","def striphtml(content):\n\tif not isinstance(content, basestring):\n\t\treturn u''\n\tcontent = re_script.sub(u'',content)\n\tdoc = html.fragment_fromstring(content, create_parent=True)\n\tclean.clean_html(doc)\n\treturn unicode(re_nl.sub(u'', doc.text_content()))","def _npgStripExtra(self, htmlStr):\n lines = htmlStr.splitlines()\n start, end = (0, 0)\n for i, line in enumerate(lines):\n if '<article>' in line and start != 0:\n start = i\n if '</article>' in line and end != 0:\n end = i\n\n if start != 0 and end != 0 and end > start and end - start > 10 and end < len(lines):\n logging.log(5, 'stripping some extra html')\n return ''.join(lines[start:end + 1])\n else:\n return htmlStr","def remove_tags(text):\n tree = html.fromstring(text)\n return tree.xpath(\"//text()\")","def html_to_text(html, target_elements=None):\n soup = BeautifulSoup(html)\n\n for script in soup(\n [\"script\", \"style\"]\n ): # remove all javascript and stylesheet code\n script.extract()\n\n targets = []\n\n if target_elements:\n targets = soup.find_all(target_elements)\n\n if target_elements and len(targets) > 3:\n text = \" \".join([t.text for t in targets])\n else:\n text = soup.get_text()\n\n # break into lines and remove leading and trailing space on each\n lines = (line.strip() for line in text.splitlines())\n # break multi-headlines into a line each\n chunks = (phrase.strip() for line in lines for phrase in line.split(\" \"))\n # drop blank lines\n text = \"\\n\".join(chunk for chunk in chunks if chunk)\n return text","def clean_html(self):\n self.cleaned_html = self.html.strip()\n for begin_splitter in self.begin_splitters:\n self.cleaned_html = self.cleaned_html.split(begin_splitter)[-1]\n for end_splitter in self.end_splitters:\n self.cleaned_html = self.cleaned_html.split(end_splitter)[0]\n self.cleaned_html = self.cleaned_html.strip()\n return self.cleaned_html","def get_html2text(html):\n text_maker = html2text.HTML2Text()\n text_maker.body_width = 0\n return text_maker.handle(html)","def strip_html(unclean, tags=[]):\n # We make this noop for non-string, non-collection inputs so this function can be used with higher-order\n # functions, such as rapply (recursively applies a function to collections)\n if not isinstance(unclean, basestring) and not is_iterable(unclean) and unclean is not None:\n return unclean\n return bleach.clean(unclean, strip=True, tags=tags, attributes=[], styles=[])","def extract_text(soup, result):\n if soup:\n for t in soup.children:\n if type(t) == NavigableString:\n # Text content node\n result.append(t)\n elif isinstance(t, NavigableString):\n # Comment, CDATA or other text data: ignore\n pass\n elif t.name in whitespace_tags:\n # Tags that we interpret as whitespace, such as <br> and <img>\n result.append_whitespace()\n elif t.name in block_tags:\n # Nested block tag\n result.begin() # Begin block\n extract_text(t, result)\n result.end() # End block\n elif t.name not in exclude_tags:\n # Non-block tag\n extract_text(t, result)","def remove_html_tags(text: str) -> str:\n clean = re.compile('<.*?>')\n return re.sub(clean, '', str(text))","def get_txt(url):\n soup = make_soup(url)\n\n # remove scripts and styling\n for script in soup([\"script\", \"style\"]):\n script.extract() # rip it out\n text = soup.get_text()\n\n # clean data\n lines = (line.strip() for line in text.splitlines())\n chunks = (phrase.strip() for line in lines for phrase in line.split(\" \"))\n text = '\\n'.join(chunk for chunk in chunks if chunk)\n\n return text","def strip_logfile_html(text):\n out_text = \"\"\n buff = \"\"\n start_tag = \"\"\n end_tag = \"\"\n context = \"none\"\n for i in range(len(text)):\n c = text[i]\n # print \"c = \"+str(c)+\" context = \"+str(context)\n if c == \"<\":\n if context == \"none\":\n # Possible start of a tag, depending on\n # next character\n context = \"putative_tag\"\n buff = c\n else:\n # Everything up to this needs to\n # be dumped directly to output\n out_text = out_text + escape_xml_characters(buff)\n elif context == \"putative_tag\":\n buff = buff + c\n if c.isalpha():\n context = \"start_tag\"\n elif c == \"/\":\n context = \"end_tag\"\n elif c == \"!\":\n context = \"comment_tag\"\n else:\n # Not a tag so dump it\n context = \"none\"\n out_text = out_text + escape_xml_characters(buff)\n elif context == \"start_tag\" or context == \"end_tag\" or context == \"comment_tag\":\n buff = buff + c\n if c == \">\":\n if context == \"start_tag\":\n # End of a start tag\n # Process it and see if we can\n # salvage something\n salvage_text = salvage_tag_data(buff)\n if salvage_text != \"\":\n out_text = out_text + escape_xml_characters(salvage_text)\n # Reset the buffer\n context = \"none\"\n buff = \"\"\n elif context == \"end_tag\":\n # End of an end tag\n # Throw this away (for now)\n context = \"none\"\n buff = \"\"\n elif context == \"comment_tag\":\n # End of a comment\n # Throw this away (for now)\n context = \"none\"\n buff = \"\"\n else:\n # Nothing special about this\n # Add to the output\n out_text = out_text + escape_xml_characters(c)\n # Finished - append the remaining buffer\n out_text = out_text + escape_xml_characters(buff)\n return remove_blank_lines(out_text)","def remove_tags(text):\n # Remove HTML tags\n soup = BeautifulSoup(text, \"html.parser\")\n [s.extract() for s in soup(['iframe', 'script'])]\n stripped_text = soup.get_text()\n stripped_text = re.sub(r'[\\r|\\n|\\r\\n]+', '\\n', stripped_text)\n \n \n text = unicodedata.normalize('NFKD', stripped_text).encode('ascii', 'ignore').decode('utf-8', 'ignore') # Remove Accented characters\n text = re.sub(r'[^\\x00-\\x7F]+','', text) # Remove Non-Ascii characters\n text = re.sub(\"[a-z0-9\\.\\-+_]+@[a-z0-9\\.\\-+_]+\\.[a-z]+\", '', text) # Remove Emails\n text = re.sub(r\"http\\S+\", \"\", text) # Remove URLs\n return text","def promed_html_to_formatted_text(html):\n # This is to fix some cases in malformed html where <s aren't esacaped.\n # >s can be parsed without escaping.\n normed_html = html.\\\n replace(\"<<\", \"<<\").\\\n replace(\"<http\", \"<http\").\\\n replace(\"< \", \"< \")\n return dom_tree_to_formatted_text(BeautifulSoup(normed_html))","def safeHTML(s):\n parser = StrippingParser()\n parser.feed(s)\n parser.close()\n parser.cleanup()\n return parser.result","def remove_html(x: str) -> str:\n regex = r\"<.+?>\"\n return re.sub(regex, \"\", x)","def extract_text(html, guess_punct_space=True):\n sel = cleaned_selector(html)\n return selector_to_text(sel, guess_punct_space=guess_punct_space)","def remove_html_tags(text):\n tag_pattern = re.compile(r'<[^>]+>')\n return tag_pattern.sub('', text)","def removeMarkup(self, text):\n text = TextFormat.stripTagRe.sub('', text)\n return unescape(text)","def remove_html_tags(text):\n import re\n clean = re.compile('<.*?>|\\\\n')\n return re.sub(clean, '', text)","def _get_text(self, remove_newlines=True):\n if not self.text:\n url = self.url\n try:\n self.log.debug(\"Try to get content from page {}\".format(url))\n r = requests.get(url)\n except requests.exceptions.RequestException as e:\n self.log.warn(\"Unable to get page content of the url: {url}. \"\n \"The reason: {exc!r}\".format(url=url, exc=e))\n raise ParsingError(e.strerror)\n\n ud = UnicodeDammit(r.content, is_html=True)\n\n enc = ud.original_encoding.lower()\n declared_enc = ud.declared_html_encoding\n if declared_enc:\n declared_enc = declared_enc.lower()\n # possible misregocnition of an encoding\n if (declared_enc and enc != declared_enc):\n detect_dict = chardet.detect(r.content)\n det_conf = detect_dict[\"confidence\"]\n det_enc = detect_dict[\"encoding\"].lower()\n if enc == det_enc and det_conf < THRESHOLD_OF_CHARDETECT:\n enc = declared_enc\n # if page contains any characters that differ from the main\n # encoding we will ignore them\n content = r.content.decode(enc, \"ignore\").encode(enc)\n htmlparser = etree.HTMLParser(encoding=enc)\n root = etree.HTML(content, parser=htmlparser)\n etree.strip_elements(root, html.etree.Comment, \"script\", \"style\")\n text = html.tostring(root, method=\"text\", encoding=\"unicode\")\n\n if remove_newlines:\n self.log.debug(str(type(text)))\n text = re.sub('\\s+', ' ', text)\n self.text = text\n\n return self.text","def get_text_only(self, soup):\n val = soup.string\n # see if we have a text element\n if val is None:\n conts = soup.contents\n resulttext = ''\n # not text so continue recursing through the tags\n for tag in conts:\n subtext = self.get_text_only(tag)\n resulttext += subtext + '\\n'\n return resulttext\n return val.strip()","def convert_html():\n return","def _remove_tags(self, text):\n try:\n result = \"\".join(xml.etree.ElementTree.fromstring(text).itertext()).replace(\n \"\\n\\n\", \"\\n\"\n )\n except: # pylint: disable=bare-except\n result = text\n return result","def remove_html_tags(text):\r\n clean = re.compile('<.*?>')\r\n return re.sub(clean, '', text)","def remove_tags(raw):\n cleanr = re.compile('<.*?>')\n cleantext = re.sub(cleanr, ' ', raw)\n return cleantext","def RemoveHTMLTags(self, data):\n return self.UnescapeHTMLEntities(lxml.html.fromstring(data).text_content())","def strip(html_string):\n html_string = html_string.strip()\n html_string = re.sub(\"[^\\x00-\\x7F]\", \" \", html_string)\n html_string = re.sub(\" |\\n|\\r|\\t|\\r\\n\", \" \", html_string)\n html_string = re.sub(\"<(p|span|div|a).+?>\", \" \", html_string)\n html_string = re.sub(\"</(p|span|div|a)>\", \" \", html_string)\n html_string = re.sub(\"</?(b|em|strong|small)>\", \" \", html_string)\n html_string = re.sub(\"<input.+?/>\", \" \", html_string)\n html_string = re.sub(\"\\s{2,}\", \" \", html_string)\n html_string = html_string.encode(\"ascii\", \"ignore\")\n return html_string","def strip_tags(src):\n res = ''.join(BeautifulSoup(src).findAll(text=True))\n res = re.sub(r\"\\s+\", \" \", res).strip()\n return res","def remove_html_tags(text):\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text)","def text_of(soup):\n return ''.join([str(x) for x in soup.findAll(text=True)])","def remove_html_tags(text):\n import re\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text)","def remove_html_tags(text):\n import re\n clean = re.compile('<.*?>')\n return re.sub(clean, '', text)","def convert_html_to_text(html_str: str, ignore_tags: None = None) -> str:\n if not html_str:\n return \"\"\n if html_parser is None:\n return strip_tags(html_str)\n\n parser = HTMLParser(encoding=\"utf-8\")\n root = html_parser.fromstring(html_str.encode(\"utf-8\"), parser=parser)\n try:\n body = root.xpath(\"./body\")[0]\n except IndexError:\n # No body element\n body = root\n\n for tag in HTML_GARBAGE:\n els = body.xpath(\".//\" + tag)\n for el in els:\n el.getparent().remove(el)\n\n convert_element(body, ignore_tags=ignore_tags)\n\n text = html_parser.tostring(\n body, pretty_print=True, method=\"text\", encoding=\"utf-8\"\n ).decode(\"utf-8\")\n\n return \"\\n\".join(x.strip() for x in text.splitlines()).strip()","def remove_html(self):\n text_func = self._remove_html\n args = ()\n kwargs = {}\n DataSet._apply_to_texts(text_func, self._meta, args, kwargs)\n return None","def _remove_html_tags(self, text: str) -> str:\n pattern = r\"\"\"\n (?x) # Turn on free-spacing\n <[^>]+> # Remove <html> tags\n | &([a-z0-9]+|\\#[0-9]{1,6}|\\#x[0-9a-f]{1,6}); # Remove \n \"\"\"\n return re.sub(pattern, \" \", str(text))","def get_gp_text_description(html):\n m = re.search('<div id=\"doc-description-container\"', html)\n desc_section_start = html[m.start():]\n m = re.search('</div>', desc_section_start)\n desc_section = desc_section_start[:m.start()]\n cleaned_desc = filter(lambda x: x in string.printable, desc_section)\n parser = HTMLParser()\n return parser.unescape(nltk.clean_html(cleaned_desc))","def bs_preprocess(html):\n pat = re.compile('(^[\\s]+)|([\\s]+$)', re.MULTILINE)\n html = re.sub(pat, '', html) # remove leading and trailing whitespaces\n html = re.sub('\\n', ' ', html) # convert newlines to spaces\n # this preserves newline delimiters\n html = re.sub('[\\s]+<', '<', html) # remove whitespaces before opening tags\n html = re.sub('>[\\s]+', '>', html) # remove whitespaces after closing tags\n return html","def htmlExtractPart(page, tag, attrs):\n try:\n htmlParsePage(page)\n except UnicodeEncodeError:\n logging.warn('could not parse html')\n return page['data']\n\n bs = page['parsedHtml']\n el = bs.find(tag, attrs=attrs)\n if el != None:\n logging.debug('Successfully stripped html')\n return str(el)\n else:\n logging.debug('Could not strip html')\n return page['data']\n return","def remove_Tags(self,text):\n cleaned_text = re.sub('<[^<]+?>', '', text)","def remove_html_tags(data):\n p = re.compile(r'<.*?>')\n return p.sub('', data)","def clean_text(self, text: str) -> str:\n url_regex = r\"https?:\\/\\/(www\\.)?[-a-zA-Z0-9@:%._\\+~#=]{2,256}\\.[a-z]{2,4}\\b([-a-zA-Z0-9@:%_\\+.~#?&//=]*)\"\n\n text = text.strip(\" _\\t\\n\")\n text = text.split(\"____\")[0] # To remove footnotes\n text = text.strip(\" _\\t\\n\")\n text = re.sub(url_regex, \"<url>\", text) # To remove URLs\n text = re.sub(r\">.*(?!(\\n+))$\", \"\",\n text) # To remove quotes at last.\n text = re.sub(r\">(.*)\\n\", \"<startq> \\g<1> <endq>\",\n text) # To add start quote, end quote tags\n text = re.sub(r\"\\n\", \" \", text)\n text = text.rstrip(\" _\\n\\t\")\n text = re.sub(r\"\\n\", \" \", text)\n text = re.sub(r\"\\r\", \" \", text)\n text = text.lower()\n if self.mask_dms:\n text = self.mask_disc_markers(text)\n return text","def remove_html_tags(text):\n clean = re.compile('<.*?>|– ')\n return re.sub(clean, '', text)","def remove_html_tags(text):\n clean = re.compile('<.*?>|– ')\n return re.sub(clean, '', text)","def extractContent(content):\n soup = BeautifulSoup(content, 'html.parser')\n return soup.get_text()","def convert_content(self, html):\n\n try:\n dom = BeautifulSoup(html, 'html.parser')\n return self.parse_content(dom)\n except:\n return html","def parsingconvtext(retrievedtext,customtextlist):\r\n if not retrievedtext: #in case empty text \r\n retrievedtext=changenonetostr(retrievedtext)\r\n newtext=BeautifulSoup(retrievedtext).get_text() \r\n #newtext=changenonetostr(retrievedtext)\r\n #newtext=BeautifulSoup(newtext).get_text() \r\n #remove http links\r\n newtext=re.sub(r'http\\S+', '', newtext)\r\n newtext=re.sub(r'\\r\\r\\r\\n', ' ', newtext)\r\n #remove LL specific text\r\n if customtextlist:\r\n for i in customtextlist:\r\n newtext=re.sub(i, '', newtext)\r\n return newtext","def html_text(self):\n return g.markdown_wiki.convert(self.data.text)","def cleaningHTML(text):\n # HTML-Entities decodieren\n h = html.parser.HTMLParser(convert_charrefs=True)\n text = h.unescape(text)\n \n # Geschützte Leerzeichen löschen\n text = re.sub('\\u00A0', \" \", text)\n text = re.sub(r'&', r'&', text)\n text = re.sub(r'<a .*?>', r'', text)\n text = re.sub(r'</a>', r'', text)\n return text","def get_html(self):\n if not self.id_video or not self.original_url or not self.xml_response:\n return ''\n return self.xml_response.find('html').text","def clear_text(body):\n soup = BeautifulSoup(body, features=\"html.parser\")\n for a in soup.findAll('a'):\n # print(a)\n # del a['href']\n a.replaceWithChildren()\n\n # for code in soup.findAll('code'):\n # # print(a)\n # # del a['href']\n # print(\"888888888888888888\")\n # print(code)\n # print(\"888888888888888888\")\n # #code.replaceWithChildren()\n #\n # del code\n\n return str(soup)","def read_url(url):\n\thtml = urllib.urlopen(url).read().decode('utf8')\n\ttext = plaintext(html)\n\tlines = text.splitlines()\n\tlines = [line for line in lines if line.strip() != '']\n\tlines = [line for line in lines if line.startswith('<') == False]\n\tlines = [line for line in lines if ('{') not in line]\n\n\tprint lines\n \n\ttext ='\\n'.join(line for line in lines)\n\n\treturn text","def unhtml(cls, text):\n parser = cls()\n parser.feed(text)\n return parser","def clean_html(input):\n p = HTMLParser(tree=treebuilders.getTreeBuilder(\"dom\"))\n dom_tree = p.parseFragment(input)\n walker = treewalkers.getTreeWalker(\"dom\")\n stream = walker(dom_tree)\n\n s = HTMLSerializer(omit_optional_tags=False)\n return \"\".join(s.serialize(stream))","def get_visible_text(_text):\n #text = _text.decode('utf-8', 'ignore').lower() # Don't get hung up on unicode chars in foreign languages\n text = _text.lower()\n text = re.compile(r'<').sub(' <',text) # These two lines keep words from getting smushed\n text = re.compile(r'>').sub('> ',text) # together when two they are only separated by tags.\n soup = BeautifulSoup(text, 'lxml')\n\n # decompose removes the tag and it's text content completely\n for s in soup(['script','code','style']):\n s.decompose()\n\n text = soup.get_text()\n # compress space to reduce footprint and fit on one line so it neatly fits in csv file\n text = re.compile(r'\\s+').sub(' ',text).strip()\n return text"],"string":"[\n \"def remove_html( html):\\n return html2txt(html)\",\n \"def strip_html(text):\\n soup = BeautifulSoup(text, \\\"html.parser\\\")\\n return soup.get_text()\",\n \"def strip_html(inputString):\\r\\n return BeautifulSoup(inputString, \\\"html.parser\\\").text\",\n \"def strip_html_tags(text):\\r\\n soup = BeautifulSoup(text, 'lxml')\\r\\n stripped_text = soup.get_text(separator=\\\" \\\")\\r\\n return stripped_text\",\n \"def remove_html(txt):\\r\\n TAG_RE = re.compile(r'<[^>]+>')\\r\\n return TAG_RE.sub(\\\"\\\", txt).strip()\",\n \"def strip_html_tags(text):\\n soup = BeautifulSoup(text, \\\"html.parser\\\")\\n stripped_text = soup.get_text(separator=\\\" \\\")\\n return stripped_text\",\n \"def strip_html_tags(text):\\n soup = BeautifulSoup(text, \\\"html.parser\\\")\\n stripped_text = soup.get_text(separator=\\\" \\\")\\n return stripped_text\",\n \"def scrubHTML( html ):\\n parser = StrippingParser()\\n parser.feed( html )\\n parser.close()\\n return parser.result\",\n \"def html_to_text(text):\\n # type (str) -> str\\n soup = BeautifulSoup(text, \\\"html.parser\\\")\\n return \\\"\\\\n\\\".join(soup.stripped_strings)\",\n \"def clean_html(html):\\n html = re.sub(r\\\"(?s)<!--(.*?)-->[\\\\n]?\\\", \\\"\\\\\\\\1\\\", html)\\n html = re.sub(r\\\"<!--\\\", \\\"\\\", html)\\n if html == '':\\n return ''\\n s = MLStripper()\\n s.feed(html)\\n return s.get_data().strip()\",\n \"def _strip_excerpt(self, raw_html):\\n clean_regex = re.compile(\\\"<.*?>\\\")\\n clean_text = re.sub(clean_regex, \\\"\\\", raw_html)\\n return html.unescape(clean_text).replace(\\\"\\\\n\\\", \\\"\\\")\",\n \"def remove_html_tags(text: str) -> str:\\n return re.sub('<.*?>', '', text).strip()\",\n \"def extract_page_text(html):\\n soup = bs4.BeautifulSoup(html)\\n\\n # Remove <script/> and <style/> content\\n for script in soup([\\\"script\\\", \\\"style\\\"]):\\n script.extract()\\n\\n text = soup.get_text()\\n\\n # Strip leading and trailing whitespace from each line, then join all the\\n # non-empty lines together.\\n lines = (line.strip() for line in text.splitlines())\\n text = '\\\\n'.join(line for line in lines if line)\\n\\n return text\",\n \"def extract(content):\\n parser = MyHTMLParser()\\n parser.textBody = []\\n parser.feed(content)\\n textBody = parser.textBody\\n textBody = \\\" \\\".join(textBody)\\n textBody = textBody.replace('\\\\xa0', \\\" \\\")\\n return textBody.strip()\",\n \"def html_to_text(html):\\n html_parser = 'html5lib'\\n soup = BeautifulSoup(html, html_parser)\\n pretty_html = soup.prettify()\\n pretty_soup = BeautifulSoup(pretty_html, html_parser)\\n text = pretty_soup.get_text()\\n lines = [s for s in text.splitlines() if not re.search(r'^\\\\s*$', s)]\\n return os.linesep.join(lines)\",\n \"def strip_html(text: str, **serializer_kwargs: bool):\\n cleaner = get_cleaner(**serializer_kwargs)\\n text = cleaner.clean(text)\\n return text\",\n \"def remove_html_tags(html_text: str) -> str:\\n document = fromstring(html_text)\\n text = document.text_content()\\n return text.strip()\",\n \"def remove_html(text):\\n return re.sub(r'<.*?>', r'', text)\",\n \"def remove_html_tags(text):\\n print('VOU REMOVER AS TAGS DA STRING')\\n clean = re.compile('<.*?>')\\n print('',re.sub(clean, '', text))\\n return re.sub(clean, '', text)\",\n \"def strip_tags(html):\\n if html is None:\\n html = ''\\n s = MLStripper()\\n s.feed(html)\\n return s.get_data()\",\n \"def strip_tags(self, html):\\n s = MLStripper()\\n s.feed(html)\\n return s.get_data()\",\n \"def _get_text(raw_html):\\n bs = BeautifulSoup(raw_html)\\n text_nodes = bs.find_all(_is_text_tag)\\n text_elements = [_get_child_text(node) for node in text_nodes]\\n return ' '.join(chain(*chain(*text_elements)))\",\n \"def stripHtml(html):\\n\\t# kinda works\\n\\tres = html.replace(\\\"<\\\", \\\"<\\\")\\n\\tres = res.replace(\\\">\\\", \\\">\\\")\\n\\tres = re.sub(r'<[^>]+>', '', res)\\n\\treturn res\",\n \"def text_from_html(body):\\n soup = BeautifulSoup(body, \\\"html.parser\\\")\\n texts = soup.findAll(text=True)\\n visible_texts = filter(tag_visible, texts)\\n return \\\" \\\".join(t.strip() for t in visible_texts)\",\n \"def stripHTMLTags (html):\\n text = html\\n \\n # apply rules in given order!\\n rules = [\\n { r'>\\\\s+' : u'>'}, # remove spaces after a tag opens or closes\\n { r'\\\\s+' : u' '}, # replace consecutive spaces\\n { r'\\\\s*<br\\\\s*/?>\\\\s*' : u'\\\\n'}, # newline after a <br>\\n { r'</(div)\\\\s*>\\\\s*' : u'\\\\n'}, # newline after </p> and </div> and <h1/>...\\n { r'</(p|h\\\\d)\\\\s*>\\\\s*' : u'\\\\n\\\\n'}, # newline after </p> and </div> and <h1/>...\\n { r'<head>.*<\\\\s*(/head|body)[^>]*>' : u'' }, # remove <head> to </head>\\n { r'<a\\\\s+href=\\\"([^\\\"]+)\\\"[^>]*>.*</a>' : r'\\\\1' }, # show links instead of texts\\n { r'[ \\\\t]*<[^<]*?/?>' : u'' }, # remove remaining tags\\n { r'^\\\\s+' : u'' } # remove spaces at the beginning\\n ]\\n \\n for rule in rules:\\n for (k,v) in rule.items():\\n regex = re.compile (k)\\n text = regex.sub (v, text)\\n \\n # replace special strings\\n special = {\\n ' ' : ' ', '&' : '&', '"' : '\\\"',\\n '<' : '<', '>' : '>'\\n }\\n \\n for (k,v) in special.items():\\n text = text.replace (k, v)\\n\\n filtered = filter(lambda x: not re.match(r'^\\\\s*$', x), text) \\n finaltext = re.sub(u'分享：','', filtered)\\n return finaltext\",\n \"def strip_html_tags(text):\\n if text is np.nan:\\n return text\\n regex = re.compile(r\\\"<.*?>\\\")\\n return re.sub(regex, \\\"\\\", text)\",\n \"def extract_html(tag):\\n s = unescape(remove_all_empty_tags(tag).renderContents())\\n if type(s) != unicode:\\n return s.decode('utf-8')\\n return s\",\n \"def remove_html_tags(self,text):\\n #https://medium.com/@jorlugaqui/how-to-strip-html-tags-from-a-string-in-python-7cb81a2bbf44\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', text)\",\n \"def html_to_text(html):\\n s = TextExtractorHTMLParser()\\n s.feed(html)\\n return s.get_text()\",\n \"def extractText(text):\\n soup = BeautifulSoup(text, 'html.parser')\\n for code in soup.find_all('code'):\\n code.decompose()\\n return soup.get_text()\",\n \"def strip_html(html_str):\\n return bleach.clean(html_str, tags=[], attributes={},\\n styles=[], strip=True)\",\n \"def _html_text(self, html):\\n ee = None\\n try: return html.html_text()\\n except Exception, e: ee = e; pass\\n try: return html.xml_text()\\n except Exception, e: print \\\"HtmlDocument/text\\\", ee, e; pass\\n try: return str(html)\\n except Exception, e: print \\\"HtmlDocument/text\\\", e; return \\\" \\\"\",\n \"def extractText(postSoup):\\n for tag in postSoup.findAll(True):\\n if tag.name in (\\\"code\\\"):\\n tag.extract()\\n else:\\n tag.hidden=True\\n\\n return postSoup.renderContents()\",\n \"def get_text_hook(raw):\\n soup = bs4.BeautifulSoup(quopri.decodestring(raw), features=\\\"lxml\\\")\\n return soup.text\",\n \"def extract_answer_from_html(self, html):\\n if html.strip().startswith('<'):\\n soup = bs4.BeautifulSoup(html, 'html.parser')\\n\\n for p in soup.find_all('p'):\\n if self.REPLY_RE.match(p.text):\\n for el in list(p.previous_elements):\\n if isinstance(el, bs4.element.Tag):\\n el.decompose()\\n p.decompose()\\n break\\n\\n return str(soup)\\n else:\\n # plain text\\n match = self.REPLY_RE.search(html)\\n if match:\\n return html[match.end(0):]\\n\\n return html\",\n \"def strip_html(unclean):\\n # We make this noop for non-string, non-collection inputs so this function can be used with higher-order\\n # functions, such as rapply (recursively applies a function to collections)\\n if not isinstance(unclean, basestring) and not is_iterable(unclean) and unclean is not None:\\n return unclean\\n return bleach.clean(unclean, strip=True, tags=[], attributes=[], styles=[])\",\n \"def text_from_html(soup):\\n\\n texts = soup.findAll(text=True)\\n visible_texts = filter(tag_visible, texts)\\n\\n return u\\\" \\\".join(t.strip() for t in visible_texts)\",\n \"def unhtmlify(html):\\n return unescape(re.sub(r'<.*?>', '', html))\",\n \"def stripHTMLTags (html):\\r\\n import re\\r\\n text = html\\r\\n \\r\\n # apply rules in given order!\\r\\n rules = [\\r\\n { r'>\\\\s+' : u'>'}, # remove spaces after a tag opens or closes\\r\\n { r'\\\\s+' : u' '}, # replace consecutive spaces\\r\\n { r'\\\\s*<br\\\\s*/?>\\\\s*' : u'\\\\n'}, # newline after a <br>\\r\\n #{ r'</(div)\\\\s*>\\\\s*' : u'\\\\n'}, # newline after </p> and </div> and <h1/>...\\r\\n #{ r'</(p|h\\\\d)\\\\s*>\\\\s*' : u'\\\\n\\\\n'}, # newline after </p> and </div> and <h1/>...\\r\\n { r'<head>.*<\\\\s*(/head|body)[^>]*>' : u'' }, # remove <head> to </head>\\r\\n { r'<a\\\\s+href=\\\"([^\\\"]+)\\\"[^>]*>.*</a>' : u'' }, # show links instead of texts\\r\\n { r'[ \\\\t]*<[^<]*?/?>' : u'' }, # remove remaining tags\\r\\n { r'^\\\\s+' : u'' } # remove spaces at the beginning\\r\\n ]\\r\\n \\r\\n for rule in rules:\\r\\n for (k,v) in rule.items():\\r\\n regex = re.compile (k)\\r\\n text = regex.sub (v, text)\\r\\n \\r\\n # replace special strings\\r\\n special = {\\r\\n ' ' : ' ', '&' : '&', '"' : '\\\"',\\r\\n '<' : '<', '>' : '>'\\r\\n }\\r\\n \\r\\n for (k,v) in special.items():\\r\\n text = text.replace (k, v)\\r\\n \\r\\n return text\",\n \"def strip_markup(text):\\n html_tag_regex = re.compile(\\n r'<'\\n r'[(--)\\\\?\\\\!\\\\%\\\\/]?'\\n r'[a-zA-Z0-9#\\\\\\\"\\\\=\\\\s\\\\.\\\\;\\\\:\\\\%\\\\&?!,\\\\+\\\\*\\\\-_\\\\/]+'\\n r'\\\\/?>',\\n re.MULTILINE | re.UNICODE\\n )\\n if text:\\n text = re.sub(html_tag_regex, ' ', text)\\n return text\",\n \"def strip_tags(text):\\n # Remove header tags\\n p = re.compile(\\\"<\\\\?.+?\\\\?>\\\") \\n text = re.sub(p, \\\"\\\", text)\\n\\n # Remove <HOO>, <p> and <s> tags\\n text = text.replace(\\\"<p>\\\",\\\"\\\")\\n text = text.replace(\\\"</p>\\\",\\\"\\\")\\n text = text.replace(\\\"<s>\\\",\\\"\\\")\\n text = text.replace(\\\"</s>\\\",\\\"\\\")\\n text = text.replace(\\\"<HOO>\\\",\\\"\\\")\\n text = text.replace(\\\"</HOO>\\\",\\\"\\\")\\n\\n return text\",\n \"def strip_tags_from_html(html):\\n\\n tag_re = re_compile(r'(<!--.*?-->|<[^>]*>)')\\n return tag_re.sub('', html)\",\n \"def clean_html(soup):\\n html = str(soup.findAll('p', text=True)).strip()\\n tags = re.compile('<.*?>')\\n clean_2 = re.sub(tags, '', html)\\n line_removed = clean_2.replace('\\\\n', ' ').replace('\\\\r', '').replace('’', ' ')\\n return re.sub(r\\\"[-()\\\\\\\"#”/@“—;:<>{}'`+=~|!?,]\\\", \\\"\\\", line_removed).strip()\",\n \"def parsed_html_lean():\\n return utils.parse_html(\\n \\\"\\\"\\\"\\n <!doctype hmtl>\\n <html>\\n <head>\\n <title>Page title</title>\\n </head>\\n <body>\\n <h1>Django Auto AMP</h1>\\n <p>Generate automatic AMP from your Django templates</p>\\n </body>\\n </html>\\n \\\"\\\"\\\"\\n )\",\n \"def clean_html(text):\\n cleanr = re.compile(\\\"<.*?>\\\")\\n clean_text = re.sub(cleanr, \\\"\\\", text)\\n return clean_text\",\n \"def remove_html_tags_fun(self):\\n cleaner = re.compile('<.*?>')\\n cleaned_text = re.sub(cleaner, '', self.doc)\\n cleaned_text = re.sub('[\\\\n\\\\t]', '', cleaned_text)\\n self.doc = cleaned_text\",\n \"def remove_html_tags(text):\\n import re\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', text).rstrip('...')\",\n \"def striphtml(content):\\n\\tif not isinstance(content, basestring):\\n\\t\\treturn u''\\n\\tcontent = re_script.sub(u'',content)\\n\\tdoc = html.fragment_fromstring(content, create_parent=True)\\n\\tclean.clean_html(doc)\\n\\treturn unicode(re_nl.sub(u'', doc.text_content()))\",\n \"def _npgStripExtra(self, htmlStr):\\n lines = htmlStr.splitlines()\\n start, end = (0, 0)\\n for i, line in enumerate(lines):\\n if '<article>' in line and start != 0:\\n start = i\\n if '</article>' in line and end != 0:\\n end = i\\n\\n if start != 0 and end != 0 and end > start and end - start > 10 and end < len(lines):\\n logging.log(5, 'stripping some extra html')\\n return ''.join(lines[start:end + 1])\\n else:\\n return htmlStr\",\n \"def remove_tags(text):\\n tree = html.fromstring(text)\\n return tree.xpath(\\\"//text()\\\")\",\n \"def html_to_text(html, target_elements=None):\\n soup = BeautifulSoup(html)\\n\\n for script in soup(\\n [\\\"script\\\", \\\"style\\\"]\\n ): # remove all javascript and stylesheet code\\n script.extract()\\n\\n targets = []\\n\\n if target_elements:\\n targets = soup.find_all(target_elements)\\n\\n if target_elements and len(targets) > 3:\\n text = \\\" \\\".join([t.text for t in targets])\\n else:\\n text = soup.get_text()\\n\\n # break into lines and remove leading and trailing space on each\\n lines = (line.strip() for line in text.splitlines())\\n # break multi-headlines into a line each\\n chunks = (phrase.strip() for line in lines for phrase in line.split(\\\" \\\"))\\n # drop blank lines\\n text = \\\"\\\\n\\\".join(chunk for chunk in chunks if chunk)\\n return text\",\n \"def clean_html(self):\\n self.cleaned_html = self.html.strip()\\n for begin_splitter in self.begin_splitters:\\n self.cleaned_html = self.cleaned_html.split(begin_splitter)[-1]\\n for end_splitter in self.end_splitters:\\n self.cleaned_html = self.cleaned_html.split(end_splitter)[0]\\n self.cleaned_html = self.cleaned_html.strip()\\n return self.cleaned_html\",\n \"def get_html2text(html):\\n text_maker = html2text.HTML2Text()\\n text_maker.body_width = 0\\n return text_maker.handle(html)\",\n \"def strip_html(unclean, tags=[]):\\n # We make this noop for non-string, non-collection inputs so this function can be used with higher-order\\n # functions, such as rapply (recursively applies a function to collections)\\n if not isinstance(unclean, basestring) and not is_iterable(unclean) and unclean is not None:\\n return unclean\\n return bleach.clean(unclean, strip=True, tags=tags, attributes=[], styles=[])\",\n \"def extract_text(soup, result):\\n if soup:\\n for t in soup.children:\\n if type(t) == NavigableString:\\n # Text content node\\n result.append(t)\\n elif isinstance(t, NavigableString):\\n # Comment, CDATA or other text data: ignore\\n pass\\n elif t.name in whitespace_tags:\\n # Tags that we interpret as whitespace, such as <br> and <img>\\n result.append_whitespace()\\n elif t.name in block_tags:\\n # Nested block tag\\n result.begin() # Begin block\\n extract_text(t, result)\\n result.end() # End block\\n elif t.name not in exclude_tags:\\n # Non-block tag\\n extract_text(t, result)\",\n \"def remove_html_tags(text: str) -> str:\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', str(text))\",\n \"def get_txt(url):\\n soup = make_soup(url)\\n\\n # remove scripts and styling\\n for script in soup([\\\"script\\\", \\\"style\\\"]):\\n script.extract() # rip it out\\n text = soup.get_text()\\n\\n # clean data\\n lines = (line.strip() for line in text.splitlines())\\n chunks = (phrase.strip() for line in lines for phrase in line.split(\\\" \\\"))\\n text = '\\\\n'.join(chunk for chunk in chunks if chunk)\\n\\n return text\",\n \"def strip_logfile_html(text):\\n out_text = \\\"\\\"\\n buff = \\\"\\\"\\n start_tag = \\\"\\\"\\n end_tag = \\\"\\\"\\n context = \\\"none\\\"\\n for i in range(len(text)):\\n c = text[i]\\n # print \\\"c = \\\"+str(c)+\\\" context = \\\"+str(context)\\n if c == \\\"<\\\":\\n if context == \\\"none\\\":\\n # Possible start of a tag, depending on\\n # next character\\n context = \\\"putative_tag\\\"\\n buff = c\\n else:\\n # Everything up to this needs to\\n # be dumped directly to output\\n out_text = out_text + escape_xml_characters(buff)\\n elif context == \\\"putative_tag\\\":\\n buff = buff + c\\n if c.isalpha():\\n context = \\\"start_tag\\\"\\n elif c == \\\"/\\\":\\n context = \\\"end_tag\\\"\\n elif c == \\\"!\\\":\\n context = \\\"comment_tag\\\"\\n else:\\n # Not a tag so dump it\\n context = \\\"none\\\"\\n out_text = out_text + escape_xml_characters(buff)\\n elif context == \\\"start_tag\\\" or context == \\\"end_tag\\\" or context == \\\"comment_tag\\\":\\n buff = buff + c\\n if c == \\\">\\\":\\n if context == \\\"start_tag\\\":\\n # End of a start tag\\n # Process it and see if we can\\n # salvage something\\n salvage_text = salvage_tag_data(buff)\\n if salvage_text != \\\"\\\":\\n out_text = out_text + escape_xml_characters(salvage_text)\\n # Reset the buffer\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n elif context == \\\"end_tag\\\":\\n # End of an end tag\\n # Throw this away (for now)\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n elif context == \\\"comment_tag\\\":\\n # End of a comment\\n # Throw this away (for now)\\n context = \\\"none\\\"\\n buff = \\\"\\\"\\n else:\\n # Nothing special about this\\n # Add to the output\\n out_text = out_text + escape_xml_characters(c)\\n # Finished - append the remaining buffer\\n out_text = out_text + escape_xml_characters(buff)\\n return remove_blank_lines(out_text)\",\n \"def remove_tags(text):\\n # Remove HTML tags\\n soup = BeautifulSoup(text, \\\"html.parser\\\")\\n [s.extract() for s in soup(['iframe', 'script'])]\\n stripped_text = soup.get_text()\\n stripped_text = re.sub(r'[\\\\r|\\\\n|\\\\r\\\\n]+', '\\\\n', stripped_text)\\n \\n \\n text = unicodedata.normalize('NFKD', stripped_text).encode('ascii', 'ignore').decode('utf-8', 'ignore') # Remove Accented characters\\n text = re.sub(r'[^\\\\x00-\\\\x7F]+','', text) # Remove Non-Ascii characters\\n text = re.sub(\\\"[a-z0-9\\\\.\\\\-+_]+@[a-z0-9\\\\.\\\\-+_]+\\\\.[a-z]+\\\", '', text) # Remove Emails\\n text = re.sub(r\\\"http\\\\S+\\\", \\\"\\\", text) # Remove URLs\\n return text\",\n \"def promed_html_to_formatted_text(html):\\n # This is to fix some cases in malformed html where <s aren't esacaped.\\n # >s can be parsed without escaping.\\n normed_html = html.\\\\\\n replace(\\\"<<\\\", \\\"<<\\\").\\\\\\n replace(\\\"<http\\\", \\\"<http\\\").\\\\\\n replace(\\\"< \\\", \\\"< \\\")\\n return dom_tree_to_formatted_text(BeautifulSoup(normed_html))\",\n \"def safeHTML(s):\\n parser = StrippingParser()\\n parser.feed(s)\\n parser.close()\\n parser.cleanup()\\n return parser.result\",\n \"def remove_html(x: str) -> str:\\n regex = r\\\"<.+?>\\\"\\n return re.sub(regex, \\\"\\\", x)\",\n \"def extract_text(html, guess_punct_space=True):\\n sel = cleaned_selector(html)\\n return selector_to_text(sel, guess_punct_space=guess_punct_space)\",\n \"def remove_html_tags(text):\\n tag_pattern = re.compile(r'<[^>]+>')\\n return tag_pattern.sub('', text)\",\n \"def removeMarkup(self, text):\\n text = TextFormat.stripTagRe.sub('', text)\\n return unescape(text)\",\n \"def remove_html_tags(text):\\n import re\\n clean = re.compile('<.*?>|\\\\\\\\n')\\n return re.sub(clean, '', text)\",\n \"def _get_text(self, remove_newlines=True):\\n if not self.text:\\n url = self.url\\n try:\\n self.log.debug(\\\"Try to get content from page {}\\\".format(url))\\n r = requests.get(url)\\n except requests.exceptions.RequestException as e:\\n self.log.warn(\\\"Unable to get page content of the url: {url}. \\\"\\n \\\"The reason: {exc!r}\\\".format(url=url, exc=e))\\n raise ParsingError(e.strerror)\\n\\n ud = UnicodeDammit(r.content, is_html=True)\\n\\n enc = ud.original_encoding.lower()\\n declared_enc = ud.declared_html_encoding\\n if declared_enc:\\n declared_enc = declared_enc.lower()\\n # possible misregocnition of an encoding\\n if (declared_enc and enc != declared_enc):\\n detect_dict = chardet.detect(r.content)\\n det_conf = detect_dict[\\\"confidence\\\"]\\n det_enc = detect_dict[\\\"encoding\\\"].lower()\\n if enc == det_enc and det_conf < THRESHOLD_OF_CHARDETECT:\\n enc = declared_enc\\n # if page contains any characters that differ from the main\\n # encoding we will ignore them\\n content = r.content.decode(enc, \\\"ignore\\\").encode(enc)\\n htmlparser = etree.HTMLParser(encoding=enc)\\n root = etree.HTML(content, parser=htmlparser)\\n etree.strip_elements(root, html.etree.Comment, \\\"script\\\", \\\"style\\\")\\n text = html.tostring(root, method=\\\"text\\\", encoding=\\\"unicode\\\")\\n\\n if remove_newlines:\\n self.log.debug(str(type(text)))\\n text = re.sub('\\\\s+', ' ', text)\\n self.text = text\\n\\n return self.text\",\n \"def get_text_only(self, soup):\\n val = soup.string\\n # see if we have a text element\\n if val is None:\\n conts = soup.contents\\n resulttext = ''\\n # not text so continue recursing through the tags\\n for tag in conts:\\n subtext = self.get_text_only(tag)\\n resulttext += subtext + '\\\\n'\\n return resulttext\\n return val.strip()\",\n \"def convert_html():\\n return\",\n \"def _remove_tags(self, text):\\n try:\\n result = \\\"\\\".join(xml.etree.ElementTree.fromstring(text).itertext()).replace(\\n \\\"\\\\n\\\\n\\\", \\\"\\\\n\\\"\\n )\\n except: # pylint: disable=bare-except\\n result = text\\n return result\",\n \"def remove_html_tags(text):\\r\\n clean = re.compile('<.*?>')\\r\\n return re.sub(clean, '', text)\",\n \"def remove_tags(raw):\\n cleanr = re.compile('<.*?>')\\n cleantext = re.sub(cleanr, ' ', raw)\\n return cleantext\",\n \"def RemoveHTMLTags(self, data):\\n return self.UnescapeHTMLEntities(lxml.html.fromstring(data).text_content())\",\n \"def strip(html_string):\\n html_string = html_string.strip()\\n html_string = re.sub(\\\"[^\\\\x00-\\\\x7F]\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\" |\\\\n|\\\\r|\\\\t|\\\\r\\\\n\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\"<(p|span|div|a).+?>\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\"</(p|span|div|a)>\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\"</?(b|em|strong|small)>\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\"<input.+?/>\\\", \\\" \\\", html_string)\\n html_string = re.sub(\\\"\\\\s{2,}\\\", \\\" \\\", html_string)\\n html_string = html_string.encode(\\\"ascii\\\", \\\"ignore\\\")\\n return html_string\",\n \"def strip_tags(src):\\n res = ''.join(BeautifulSoup(src).findAll(text=True))\\n res = re.sub(r\\\"\\\\s+\\\", \\\" \\\", res).strip()\\n return res\",\n \"def remove_html_tags(text):\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', text)\",\n \"def text_of(soup):\\n return ''.join([str(x) for x in soup.findAll(text=True)])\",\n \"def remove_html_tags(text):\\n import re\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', text)\",\n \"def remove_html_tags(text):\\n import re\\n clean = re.compile('<.*?>')\\n return re.sub(clean, '', text)\",\n \"def convert_html_to_text(html_str: str, ignore_tags: None = None) -> str:\\n if not html_str:\\n return \\\"\\\"\\n if html_parser is None:\\n return strip_tags(html_str)\\n\\n parser = HTMLParser(encoding=\\\"utf-8\\\")\\n root = html_parser.fromstring(html_str.encode(\\\"utf-8\\\"), parser=parser)\\n try:\\n body = root.xpath(\\\"./body\\\")[0]\\n except IndexError:\\n # No body element\\n body = root\\n\\n for tag in HTML_GARBAGE:\\n els = body.xpath(\\\".//\\\" + tag)\\n for el in els:\\n el.getparent().remove(el)\\n\\n convert_element(body, ignore_tags=ignore_tags)\\n\\n text = html_parser.tostring(\\n body, pretty_print=True, method=\\\"text\\\", encoding=\\\"utf-8\\\"\\n ).decode(\\\"utf-8\\\")\\n\\n return \\\"\\\\n\\\".join(x.strip() for x in text.splitlines()).strip()\",\n \"def remove_html(self):\\n text_func = self._remove_html\\n args = ()\\n kwargs = {}\\n DataSet._apply_to_texts(text_func, self._meta, args, kwargs)\\n return None\",\n \"def _remove_html_tags(self, text: str) -> str:\\n pattern = r\\\"\\\"\\\"\\n (?x) # Turn on free-spacing\\n <[^>]+> # Remove <html> tags\\n | &([a-z0-9]+|\\\\#[0-9]{1,6}|\\\\#x[0-9a-f]{1,6}); # Remove \\n \\\"\\\"\\\"\\n return re.sub(pattern, \\\" \\\", str(text))\",\n \"def get_gp_text_description(html):\\n m = re.search('<div id=\\\"doc-description-container\\\"', html)\\n desc_section_start = html[m.start():]\\n m = re.search('</div>', desc_section_start)\\n desc_section = desc_section_start[:m.start()]\\n cleaned_desc = filter(lambda x: x in string.printable, desc_section)\\n parser = HTMLParser()\\n return parser.unescape(nltk.clean_html(cleaned_desc))\",\n \"def bs_preprocess(html):\\n pat = re.compile('(^[\\\\s]+)|([\\\\s]+$)', re.MULTILINE)\\n html = re.sub(pat, '', html) # remove leading and trailing whitespaces\\n html = re.sub('\\\\n', ' ', html) # convert newlines to spaces\\n # this preserves newline delimiters\\n html = re.sub('[\\\\s]+<', '<', html) # remove whitespaces before opening tags\\n html = re.sub('>[\\\\s]+', '>', html) # remove whitespaces after closing tags\\n return html\",\n \"def htmlExtractPart(page, tag, attrs):\\n try:\\n htmlParsePage(page)\\n except UnicodeEncodeError:\\n logging.warn('could not parse html')\\n return page['data']\\n\\n bs = page['parsedHtml']\\n el = bs.find(tag, attrs=attrs)\\n if el != None:\\n logging.debug('Successfully stripped html')\\n return str(el)\\n else:\\n logging.debug('Could not strip html')\\n return page['data']\\n return\",\n \"def remove_Tags(self,text):\\n cleaned_text = re.sub('<[^<]+?>', '', text)\",\n \"def remove_html_tags(data):\\n p = re.compile(r'<.*?>')\\n return p.sub('', data)\",\n \"def clean_text(self, text: str) -> str:\\n url_regex = r\\\"https?:\\\\/\\\\/(www\\\\.)?[-a-zA-Z0-9@:%._\\\\+~#=]{2,256}\\\\.[a-z]{2,4}\\\\b([-a-zA-Z0-9@:%_\\\\+.~#?&//=]*)\\\"\\n\\n text = text.strip(\\\" _\\\\t\\\\n\\\")\\n text = text.split(\\\"____\\\")[0] # To remove footnotes\\n text = text.strip(\\\" _\\\\t\\\\n\\\")\\n text = re.sub(url_regex, \\\"<url>\\\", text) # To remove URLs\\n text = re.sub(r\\\">.*(?!(\\\\n+))$\\\", \\\"\\\",\\n text) # To remove quotes at last.\\n text = re.sub(r\\\">(.*)\\\\n\\\", \\\"<startq> \\\\g<1> <endq>\\\",\\n text) # To add start quote, end quote tags\\n text = re.sub(r\\\"\\\\n\\\", \\\" \\\", text)\\n text = text.rstrip(\\\" _\\\\n\\\\t\\\")\\n text = re.sub(r\\\"\\\\n\\\", \\\" \\\", text)\\n text = re.sub(r\\\"\\\\r\\\", \\\" \\\", text)\\n text = text.lower()\\n if self.mask_dms:\\n text = self.mask_disc_markers(text)\\n return text\",\n \"def remove_html_tags(text):\\n clean = re.compile('<.*?>|– ')\\n return re.sub(clean, '', text)\",\n \"def remove_html_tags(text):\\n clean = re.compile('<.*?>|– ')\\n return re.sub(clean, '', text)\",\n \"def extractContent(content):\\n soup = BeautifulSoup(content, 'html.parser')\\n return soup.get_text()\",\n \"def convert_content(self, html):\\n\\n try:\\n dom = BeautifulSoup(html, 'html.parser')\\n return self.parse_content(dom)\\n except:\\n return html\",\n \"def parsingconvtext(retrievedtext,customtextlist):\\r\\n if not retrievedtext: #in case empty text \\r\\n retrievedtext=changenonetostr(retrievedtext)\\r\\n newtext=BeautifulSoup(retrievedtext).get_text() \\r\\n #newtext=changenonetostr(retrievedtext)\\r\\n #newtext=BeautifulSoup(newtext).get_text() \\r\\n #remove http links\\r\\n newtext=re.sub(r'http\\\\S+', '', newtext)\\r\\n newtext=re.sub(r'\\\\r\\\\r\\\\r\\\\n', ' ', newtext)\\r\\n #remove LL specific text\\r\\n if customtextlist:\\r\\n for i in customtextlist:\\r\\n newtext=re.sub(i, '', newtext)\\r\\n return newtext\",\n \"def html_text(self):\\n return g.markdown_wiki.convert(self.data.text)\",\n \"def cleaningHTML(text):\\n # HTML-Entities decodieren\\n h = html.parser.HTMLParser(convert_charrefs=True)\\n text = h.unescape(text)\\n \\n # Geschützte Leerzeichen löschen\\n text = re.sub('\\\\u00A0', \\\" \\\", text)\\n text = re.sub(r'&', r'&', text)\\n text = re.sub(r'<a .*?>', r'', text)\\n text = re.sub(r'</a>', r'', text)\\n return text\",\n \"def get_html(self):\\n if not self.id_video or not self.original_url or not self.xml_response:\\n return ''\\n return self.xml_response.find('html').text\",\n \"def clear_text(body):\\n soup = BeautifulSoup(body, features=\\\"html.parser\\\")\\n for a in soup.findAll('a'):\\n # print(a)\\n # del a['href']\\n a.replaceWithChildren()\\n\\n # for code in soup.findAll('code'):\\n # # print(a)\\n # # del a['href']\\n # print(\\\"888888888888888888\\\")\\n # print(code)\\n # print(\\\"888888888888888888\\\")\\n # #code.replaceWithChildren()\\n #\\n # del code\\n\\n return str(soup)\",\n \"def read_url(url):\\n\\thtml = urllib.urlopen(url).read().decode('utf8')\\n\\ttext = plaintext(html)\\n\\tlines = text.splitlines()\\n\\tlines = [line for line in lines if line.strip() != '']\\n\\tlines = [line for line in lines if line.startswith('<') == False]\\n\\tlines = [line for line in lines if ('{') not in line]\\n\\n\\tprint lines\\n \\n\\ttext ='\\\\n'.join(line for line in lines)\\n\\n\\treturn text\",\n \"def unhtml(cls, text):\\n parser = cls()\\n parser.feed(text)\\n return parser\",\n \"def clean_html(input):\\n p = HTMLParser(tree=treebuilders.getTreeBuilder(\\\"dom\\\"))\\n dom_tree = p.parseFragment(input)\\n walker = treewalkers.getTreeWalker(\\\"dom\\\")\\n stream = walker(dom_tree)\\n\\n s = HTMLSerializer(omit_optional_tags=False)\\n return \\\"\\\".join(s.serialize(stream))\",\n \"def get_visible_text(_text):\\n #text = _text.decode('utf-8', 'ignore').lower() # Don't get hung up on unicode chars in foreign languages\\n text = _text.lower()\\n text = re.compile(r'<').sub(' <',text) # These two lines keep words from getting smushed\\n text = re.compile(r'>').sub('> ',text) # together when two they are only separated by tags.\\n soup = BeautifulSoup(text, 'lxml')\\n\\n # decompose removes the tag and it's text content completely\\n for s in soup(['script','code','style']):\\n s.decompose()\\n\\n text = soup.get_text()\\n # compress space to reduce footprint and fit on one line so it neatly fits in csv file\\n text = re.compile(r'\\\\s+').sub(' ',text).strip()\\n return text\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.76679367","0.7576908","0.7565884","0.72577864","0.7234185","0.7175138","0.7175138","0.7033482","0.7032647","0.6952287","0.6933355","0.6921029","0.68994737","0.6894347","0.6892037","0.68644744","0.68379956","0.6834254","0.6825286","0.67909366","0.67255765","0.6717269","0.66878223","0.66779846","0.667475","0.6640191","0.6630029","0.6627692","0.66245556","0.65809375","0.65686023","0.6547788","0.65474373","0.6537551","0.6536873","0.6531552","0.6523046","0.65157795","0.6511008","0.64800066","0.6479707","0.64785326","0.64563334","0.6453969","0.6452686","0.6450642","0.6426643","0.64251024","0.6420514","0.64151764","0.64140177","0.63930345","0.6386971","0.638528","0.6384876","0.6368567","0.6348583","0.6347929","0.6330531","0.6300588","0.62925583","0.62895393","0.6282634","0.6282579","0.62624425","0.62463695","0.623675","0.62312376","0.62208486","0.6217436","0.6215054","0.61945367","0.6188204","0.61611295","0.6159658","0.6132703","0.6132272","0.61267334","0.61267334","0.6125412","0.6115683","0.6108977","0.6085118","0.6027864","0.6022524","0.60084224","0.60073","0.5972061","0.59672433","0.59672433","0.59658927","0.5965687","0.5945405","0.59290266","0.59288156","0.5925342","0.5925302","0.5924861","0.59145194","0.59070104","0.59043944"],"string":"[\n \"0.76679367\",\n \"0.7576908\",\n \"0.7565884\",\n \"0.72577864\",\n \"0.7234185\",\n \"0.7175138\",\n \"0.7175138\",\n \"0.7033482\",\n \"0.7032647\",\n \"0.6952287\",\n \"0.6933355\",\n \"0.6921029\",\n \"0.68994737\",\n \"0.6894347\",\n \"0.6892037\",\n \"0.68644744\",\n \"0.68379956\",\n \"0.6834254\",\n \"0.6825286\",\n \"0.67909366\",\n \"0.67255765\",\n \"0.6717269\",\n \"0.66878223\",\n \"0.66779846\",\n \"0.667475\",\n \"0.6640191\",\n \"0.6630029\",\n \"0.6627692\",\n \"0.66245556\",\n \"0.65809375\",\n \"0.65686023\",\n \"0.6547788\",\n \"0.65474373\",\n \"0.6537551\",\n \"0.6536873\",\n \"0.6531552\",\n \"0.6523046\",\n \"0.65157795\",\n \"0.6511008\",\n \"0.64800066\",\n \"0.6479707\",\n \"0.64785326\",\n \"0.64563334\",\n \"0.6453969\",\n \"0.6452686\",\n \"0.6450642\",\n \"0.6426643\",\n \"0.64251024\",\n \"0.6420514\",\n \"0.64151764\",\n \"0.64140177\",\n \"0.63930345\",\n \"0.6386971\",\n \"0.638528\",\n \"0.6384876\",\n \"0.6368567\",\n \"0.6348583\",\n \"0.6347929\",\n \"0.6330531\",\n \"0.6300588\",\n \"0.62925583\",\n \"0.62895393\",\n \"0.6282634\",\n \"0.6282579\",\n \"0.62624425\",\n \"0.62463695\",\n \"0.623675\",\n \"0.62312376\",\n \"0.62208486\",\n \"0.6217436\",\n \"0.6215054\",\n \"0.61945367\",\n \"0.6188204\",\n \"0.61611295\",\n \"0.6159658\",\n \"0.6132703\",\n \"0.6132272\",\n \"0.61267334\",\n \"0.61267334\",\n \"0.6125412\",\n \"0.6115683\",\n \"0.6108977\",\n \"0.6085118\",\n \"0.6027864\",\n \"0.6022524\",\n \"0.60084224\",\n \"0.60073\",\n \"0.5972061\",\n \"0.59672433\",\n \"0.59672433\",\n \"0.59658927\",\n \"0.5965687\",\n \"0.5945405\",\n \"0.59290266\",\n \"0.59288156\",\n \"0.5925342\",\n \"0.5925302\",\n \"0.5924861\",\n \"0.59145194\",\n \"0.59070104\",\n \"0.59043944\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20180,"cells":{"query":{"kind":"string","value":"builds the url to get the static map. puts a marker on the start and end locations. assumes start and end are in a format / have enough info to give a proper location. does clean white spaces tho"},"document":{"kind":"string","value":"def find_map(start, end, *otherlocs):\n small = \"200x200\"\n large = \"512x512\"\n start = start.replace(\" \",\"+\")\n end = end.replace(\" \",\"+\")\n small_url = g_api_base_url + static_url + small + map_type_url + small_marker_url + start + map_concat + end\n big_url = g_api_base_url + static_url + large + map_type_url + marker_url + start + map_concat + end\n for loc in otherlocs:\n loc = loc.replace(\" \", \"+\")\n small_url += loc\n big_url += loc\n small_url += goog_static_map_key\n big_url += goog_static_map_key\n return small_url, big_url"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def generate_url(self):\n if self.has_marker:\n marker_param = f'mlat={self.mlat}&mlng={self.mlng}&'\n else:\n marker_param = ''\n if self.start:\n start_param = 'start=true&'\n else:\n start_param = ''\n url = f'{MapController.MAP_URL}?{start_param}clat={self.clat}&clng={self.clng}&{marker_param}zoom={self.zoom}'\n return url","def get_static_map(start_lng, start_lat, end_lng, end_lat):\r\n geojson_str = get_map_directions(start_lng, start_lat, end_lng, end_lat)\r\n return (\r\n f\"https://api.mapbox.com/styles/v1/mapbox/streets-v11/static/\"\r\n f\"geojson({geojson_str})/auto/640x640?access_token={MAPBOX_TOKEN}\"\r\n ), geojson_str","def small_map(self):\n self.map_url = \"https://maps.googleapis.com/maps/api/staticmap?center={},{}&zoom=12&size=350x350&key={}\".format(self.lat, self.lng, api_key) \n return (self.map_url)","def google(self):\r\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\r\n middle = '&zoom=14&size=400x400&markers='\r\n suffix = '&key=AIzaSyD5nqmDGFH1SUZxJAYVtFHP7RNjjFE9CHg'\r\n marker = '+'.join(self.placeToSearch) # marker in google format, no space but + separator\r\n request = prefix + marker+middle+marker+suffix\r\n\r\n return request","def generate_googlemaps(self):\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = format_extension[self.image_output.format]\n args['publishurl'] = \"\" if self.options.url is None else self.options.url\n args['copyright'] = self.options.copyright\n\n s = \"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\">\n <head>\n <title>%(title)s</title>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"/>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\n <script type=\"text/javascript\">\n //<![CDATA[\n\n /*\n * Constants for given map\n * TODO: read it from tilemapresource.xml\n */\n\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n var opacity = 0.75;\n var map;\n var ge;\n var hybridOverlay;\n\n /*\n * Create a Custom Opacity GControl\n * https://github.com/mj10777/mapmbtilesgoogle-maps-overlay-opacity-control/\n */\n\n var CTransparencyLENGTH = 58;\n // maximum width that the knob can move (slide width minus knob width)\n\n function CTransparencyControl( overlay ) {\n this.overlay = overlay;\n this.opacity = overlay.getTileLayer().getOpacity();\n }\n CTransparencyControl.prototype = new GControl();\n\n // This function positions the slider to match the specified opacity\n CTransparencyControl.prototype.setSlider = function(pos) {\n var left = Math.round((CTransparencyLENGTH*pos));\n this.slide.left = left;\n this.knob.style.left = left+\"px\";\n this.knob.style.top = \"0px\";\n }\n\n // This function reads the slider and sets the overlay opacity level\n CTransparencyControl.prototype.setOpacity = function() {\n // set the global variable\n opacity = this.slide.left/CTransparencyLENGTH;\n this.map.clearOverlays();\n this.map.addOverlay(this.overlay, { zPriority: 0 });\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\n this.map.addOverlay(hybridOverlay);\n }\n }\n\n // This gets called by the API when addControl(new CTransparencyControl())\n CTransparencyControl.prototype.initialize = function(map) {\n var that=this;\n this.map = map;\n\n // Is this MSIE, if so we need to use AlphaImageLoader\n var agent = navigator.userAgent.toLowerCase();\n if ((agent.indexOf(\"msie\") > -1) && (agent.indexOf(\"opera\") < 1)){this.ie = true} else {this.ie = false}\n\n // create the background graphic as a <div> containing an image\n var container = document.createElement(\"div\");\n container.style.width=\"70px\";\n container.style.height=\"21px\";\n\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\";\n container.innerHTML = '<div style=\"height:21px; width:70px; ' +loader+ '\" ></div>';\n } else {\n container.innerHTML = '<div style=\"height:21px; width:70px; background-image: url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\" ></div>';\n }\n\n // create the knob as a GDraggableObject\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\";\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.overflow=\"hidden\";\n this.knob_img = document.createElement(\"div\");\n this.knob_img.style.height=\"21px\";\n this.knob_img.style.width=\"83px\";\n this.knob_img.style.filter=loader;\n this.knob_img.style.position=\"relative\";\n this.knob_img.style.left=\"-70px\";\n this.knob.appendChild(this.knob_img);\n } else {\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.backgroundImage=\"url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\";\n this.knob.style.backgroundPosition=\"-70px 0px\";\n }\n container.appendChild(this.knob);\n this.slide=new GDraggableObject(this.knob, {container:container});\n this.slide.setDraggableCursor('pointer');\n this.slide.setDraggingCursor('pointer');\n this.container = container;\n\n // attach the control to the map\n map.getContainer().appendChild(container);\n\n // init slider\n this.setSlider(this.opacity);\n\n // Listen for the slider being moved and set the opacity\n GEvent.addListener(this.slide, \"dragend\", function() {that.setOpacity()});\n //GEvent.addListener(this.container, \"click\", function( x, y ) { alert(x, y) });\n\n return container;\n }\n\n // Set the default position for the control\n CTransparencyControl.prototype.getDefaultPosition = function() {\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\n }\n\n /*\n * Full-screen Window Resize\n */\n\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n // map.checkResize();\n }\n\n\n /*\n * Main load function:\n */\n\n function load() {\n\n if (GBrowserIsCompatible()) {\n\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\n var gcr = GMapType.prototype.getCopyrights;\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\n return [\"%(copyright)s\"].concat(gcr.call(this,bounds,zoom));\n }\n\n map = new GMap2( document.getElementById(\"map\"), { backgroundColor: '#fff' } );\n\n map.addMapType(G_PHYSICAL_MAP);\n map.setMapType(G_PHYSICAL_MAP);\n\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\n\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\n GEvent.addListener(map, \"maptypechanged\", function() {\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\n map.addOverlay(hybridOverlay);\"\"\" % args\n if self.kml:\n s += \"\"\"\n } else if (map.getCurrentMapType() == G_SATELLITE_3D_MAP) {\n var url = document.location.toString();\n if (url.substr(0,4) != 'http') alert('You have to upload the tiles to a webserver to see the overlay in Google Earth Plugin');\n if (!ge) map.getEarthInstance(getEarthInstanceCB);\"\"\"\n s += \"\"\"\n } else {\n map.removeOverlay(hybridOverlay);\n }\n } );\n\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\n var mercator = new GMercatorProjection(mapMaxZoom+1);\n tilelayer.getTileUrl = function(tile,zoom) {\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n var ymax = 1 << zoom;\n var y = ymax - tile.y -1;\n var tileBounds = new GLatLngBounds(\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\n );\n if (mapBounds.intersects(tileBounds)) {\n return zoom+\"/\"+tile.x+\"/\"+y+\".%(tileformat)s\";\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n // IE 7-: support for PNG alpha channel\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\n tilelayer.isPng = function() { return true;};\n tilelayer.getOpacity = function() { return opacity; }\n\n overlay = new GTileLayerOverlay( tilelayer );\n map.addOverlay(overlay);\n\n map.addControl(new GLargeMapControl3D());\n map.addControl(new GHierarchicalMapTypeControl());\n map.addControl(new CTransparencyControl( overlay ));\n \"\"\" % args\n if self.kml:\n s += \"\"\"\n map.addMapType(G_SATELLITE_3D_MAP);\n \"\"\"\n s += \"\"\"\n\n map.enableContinuousZoom();\n map.enableScrollWheelZoom();\n\n map.setMapType(G_HYBRID_MAP);\n }\n resize();\n }\n \"\"\"\n if self.kml:\n s += \"\"\"\n function getEarthInstanceCB(object) {\n ge = object;\n var url = document.location.toString();\n var newurl = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\n if (ge) {\n var link = ge.createLink(\"\");\n if (\"%(publishurl)s\") { link.setHref(\"%(publishurl)s/doc.kml\") }\n else { link.setHref(newurl) };\n var networkLink = ge.createNetworkLink(\"\");\n networkLink.set(link, false, false);\n ge.getFeatures().appendChild(networkLink);\n } else {\n // alert(\"Initialization of the Google Earth Plugin failed. You can still open the KML file in normal Google Earth.\");\n // window.location = newurl; // JavaScript redirect to the URL of KML\n }\n }\n \"\"\" % args\n s += \"\"\"\n onresize=function(){ resize(); };\n\n //]]>\n </script>\n </head>\n <body onload=\"load()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"https://github.com/mj10777/mapmbtiles\">MapMbTiles</a>/<a href=\"http://www.klokan.cz/projects/gdal2mbtiles/\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n </body>\n </html>\n \"\"\" % args\n\n return s","def generate_googlemaps(self):\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = self.tileext\n args['publishurl'] = self.options.url\n args['copyright'] = self.options.copyright\n\n s = r\"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\" xmlns:v=\"urn:schemas-microsoft-com:vml\">\n <head>\n <title>%(title)s</title>\n <meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\"/>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>\n <script>\n //<![CDATA[\n\n /*\n * Constants for given map\n * TODO: read it from tilemapresource.xml\n */\n\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n var opacity = 0.75;\n var map;\n var hybridOverlay;\n\n /*\n * Create a Custom Opacity GControl\n * http://www.maptiler.org/google-maps-overlay-opacity-control/\n */\n\n var CTransparencyLENGTH = 58;\n // maximum width that the knob can move (slide width minus knob width)\n\n function CTransparencyControl( overlay ) {\n this.overlay = overlay;\n this.opacity = overlay.getTileLayer().getOpacity();\n }\n CTransparencyControl.prototype = new GControl();\n\n // This function positions the slider to match the specified opacity\n CTransparencyControl.prototype.setSlider = function(pos) {\n var left = Math.round((CTransparencyLENGTH*pos));\n this.slide.left = left;\n this.knob.style.left = left+\"px\";\n this.knob.style.top = \"0px\";\n }\n\n // This function reads the slider and sets the overlay opacity level\n CTransparencyControl.prototype.setOpacity = function() {\n // set the global variable\n opacity = this.slide.left/CTransparencyLENGTH;\n this.map.clearOverlays();\n this.map.addOverlay(this.overlay, { zPriority: 0 });\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\n this.map.addOverlay(hybridOverlay);\n }\n }\n\n // This gets called by the API when addControl(new CTransparencyControl())\n CTransparencyControl.prototype.initialize = function(map) {\n var that=this;\n this.map = map;\n\n // Is this MSIE, if so we need to use AlphaImageLoader\n var agent = navigator.userAgent.toLowerCase();\n if ((agent.indexOf(\"msie\") > -1) && (agent.indexOf(\"opera\") < 1)){this.ie = true} else {this.ie = false}\n\n // create the background graphic as a <div> containing an image\n var container = document.createElement(\"div\");\n container.style.width=\"70px\";\n container.style.height=\"21px\";\n\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\";\n container.innerHTML = '<div style=\"height:21px; width:70px; ' +loader+ '\" ></div>';\n } else {\n container.innerHTML = '<div style=\"height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)\" ></div>';\n }\n\n // create the knob as a GDraggableObject\n // Handle transparent PNG files in MSIE\n if (this.ie) {\n var loader = \"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\";\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.overflow=\"hidden\";\n this.knob_img = document.createElement(\"div\");\n this.knob_img.style.height=\"21px\";\n this.knob_img.style.width=\"83px\";\n this.knob_img.style.filter=loader;\n this.knob_img.style.position=\"relative\";\n this.knob_img.style.left=\"-70px\";\n this.knob.appendChild(this.knob_img);\n } else {\n this.knob = document.createElement(\"div\");\n this.knob.style.height=\"21px\";\n this.knob.style.width=\"13px\";\n this.knob.style.backgroundImage=\"url(http://www.maptiler.org/img/opacity-slider.png)\";\n this.knob.style.backgroundPosition=\"-70px 0px\";\n }\n container.appendChild(this.knob);\n this.slide=new GDraggableObject(this.knob, {container:container});\n this.slide.setDraggableCursor('pointer');\n this.slide.setDraggingCursor('pointer');\n this.container = container;\n\n // attach the control to the map\n map.getContainer().appendChild(container);\n\n // init slider\n this.setSlider(this.opacity);\n\n // Listen for the slider being moved and set the opacity\n GEvent.addListener(this.slide, \"dragend\", function() {that.setOpacity()});\n //GEvent.addListener(this.container, \"click\", function( x, y ) { alert(x, y) });\n\n return container;\n }\n\n // Set the default position for the control\n CTransparencyControl.prototype.getDefaultPosition = function() {\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\n }\n\n /*\n * Full-screen Window Resize\n */\n\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n // map.checkResize();\n }\n\n\n /*\n * Main load function:\n */\n\n function load() {\n\n if (GBrowserIsCompatible()) {\n\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\n var gcr = GMapType.prototype.getCopyrights;\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\n return [\"%(copyright)s\"].concat(gcr.call(this,bounds,zoom));\n }\n\n map = new GMap2( document.getElementById(\"map\"), { backgroundColor: '#fff' } );\n\n map.addMapType(G_PHYSICAL_MAP);\n map.setMapType(G_PHYSICAL_MAP);\n\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\n\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\n GEvent.addListener(map, \"maptypechanged\", function() {\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\n map.addOverlay(hybridOverlay);\n } else {\n map.removeOverlay(hybridOverlay);\n }\n } );\n\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\n var mercator = new GMercatorProjection(mapMaxZoom+1);\n tilelayer.getTileUrl = function(tile,zoom) {\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\n return \"http://www.maptiler.org/img/none.png\";\n }\n var ymax = 1 << zoom;\n var y = ymax - tile.y -1;\n var tileBounds = new GLatLngBounds(\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\n );\n if (mapBounds.intersects(tileBounds)) {\n return zoom+\"/\"+tile.x+\"/\"+y+\".png\";\n } else {\n return \"http://www.maptiler.org/img/none.png\";\n }\n }\n // IE 7-: support for PNG alpha channel\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\n tilelayer.isPng = function() { return true;};\n tilelayer.getOpacity = function() { return opacity; }\n\n overlay = new GTileLayerOverlay( tilelayer );\n map.addOverlay(overlay);\n\n map.addControl(new GLargeMapControl());\n map.addControl(new GHierarchicalMapTypeControl());\n map.addControl(new CTransparencyControl( overlay ));\n \"\"\" % args # noqa\n if self.kml:\n s += \"\"\"\n map.addMapType(G_SATELLITE_3D_MAP);\n map.getEarthInstance(getEarthInstanceCB);\n \"\"\"\n s += \"\"\"\n\n map.enableContinuousZoom();\n map.enableScrollWheelZoom();\n\n map.setMapType(G_HYBRID_MAP);\n }\n resize();\n }\n \"\"\"\n if self.kml:\n s += \"\"\"\n function getEarthInstanceCB(object) {\n var ge = object;\n\n if (ge) {\n var url = document.location.toString();\n url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\n var link = ge.createLink(\"\");\n if (\"%(publishurl)s\") { link.setHref(\"%(publishurl)s/doc.kml\") }\n else { link.setHref(url) };\n var networkLink = ge.createNetworkLink(\"\");\n networkLink.setName(\"TMS Map Overlay\");\n networkLink.setFlyToView(true);\n networkLink.setLink(link);\n ge.getFeatures().appendChild(networkLink);\n } else {\n // alert(\"You should open a KML in Google Earth\");\n // add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?\n }\n }\n \"\"\" % args # noqa\n s += \"\"\"\n onresize=function(){ resize(); };\n\n //]]>\n </script>\n </head>\n <body onload=\"load()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"http://www.klokan.cz/projects/gdal2tiles/\">GDAL2Tiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n </body>\n </html>\n \"\"\" % args # noqa\n\n return s","def build_url(start, end, transit_mode):\n transit = \"\"\n traffic = \"best_guess\"\n depart = \"now\"\n if transit_mode:\n transit = transit_mode\n direc_url = g_api_base_url + dir_url + \"origin=\" + start + \"&destination=\" + end + trans_url \\\n + transit + goog_dir_key\n dist_url = g_api_base_url + dis_url + units_i + or_dis_url + start + des_url + end + trans_url \\\n + transit + traffic_url + traffic + depart_url + depart + goog_dis_key\n direc_url = direc_url.replace(\" \",\"+\")\n print(\"directions :\"+ direc_url)\n dist_url = dist_url.replace(\" \",\"+\")\n return direc_url, dist_url","def get_static_google_map(filename_wo_extension, center=None, zoom=None, imgsize=\"640x640\", imgformat=\"png\",\n maptype=\"roadmap\", markers=None):\n\n # assemble the URL\n # base URL, append query params, separated by &\n request = \"http://maps.google.com/maps/api/staticmap?\"\n apiKey = os.getenv('GOOGLE_MAPS_API_KEY')\n # if center and zoom are not given, the map will show all marker locations\n request += \"key=%s&\" % apiKey\n if center != None:\n request += \"center=%s&\" % center\n if zoom != None:\n # zoom 0 (all of the world scale ) to 22 (single buildings scale)\n request += \"zoom=%i&\" % zoom\n\n request += \"size=%ix%i&\" % (imgsize) # tuple of ints, up to 640 by 640\n request += \"format=%s&\" % imgformat\n request += \"bearing=90&\"\n # request += \"maptype=%s&\" % maptype # roadmap, satellite, hybrid, terrain\n\n # add markers (location and style)\n if markers != None:\n for marker in markers:\n request += \"%s&\" % marker\n\n request = request.rstrip('&')\n # #request += \"mobile=false&\" # optional: mobile=true will assume the image is shown on a small screen (mobile device)\n # request += \"sensor=false\" # must be given, deals with getting loction from mobile device\n # try:\n urllib.request.urlretrieve(request, filename_wo_extension)","def get_driving_map(start_lng, start_lat, end_lng, end_lat):\r\n geojson_str = get_driving_directions(start_lng, start_lat, end_lng, end_lat)\r\n return (\r\n f\"https://api.mapbox.com/styles/v1/mapbox/streets-v11/static/\"\r\n f\"geojson({geojson_str})/auto/640x640?access_token={MAPBOX_TOKEN}\"\r\n ), geojson_str","def build_maps():\n return render_template(\"maps.html\")","def get_trouble_spot_map(trouble_spot_lst):\n lat_long_lst = []\n for item in trouble_spot_lst:\n latitude = item[0]\n longitude = item[1]\n married_lat_long = LAT_LONG_TMPL.format(lat=latitude, long=longitude)\n lat_long_lst.append(married_lat_long)\n\n lat_long_lst_str = ''.join(lat_long_lst)\n\n result = URL_TMPL.format(key=API_KEY, marker=MARKER_SPEC, lat_long_lst=lat_long_lst_str)\n return result","def generate_leaflet(self):\n\n args = {}\n args['title'] = self.options.title.replace('\"', '\\\\\"')\n args['htmltitle'] = self.options.title\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['centerlon'] = (args['north'] + args['south']) / 2.\n args['centerlat'] = (args['west'] + args['east']) / 2.\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['beginzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize # not used\n args['tileformat'] = self.tileext\n args['publishurl'] = self.options.url # not used\n args['copyright'] = self.options.copyright.replace('\"', '\\\\\"')\n\n s = \"\"\"<!DOCTYPE html>\n <html lang=\"en\">\n <head>\n <meta charset=\"utf-8\">\n <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no' />\n <title>%(htmltitle)s</title>\n\n <!-- Leaflet -->\n <link rel=\"stylesheet\" href=\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.css\" />\n <script src=\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.js\"></script>\n\n <style>\n body { margin:0; padding:0; }\n body, table, tr, td, th, div, h1, h2, input { font-family: \"Calibri\", \"Trebuchet MS\", \"Ubuntu\", Serif; font-size: 11pt; }\n #map { position:absolute; top:0; bottom:0; width:100%%; } /* full size */\n .ctl {\n padding: 2px 10px 2px 10px;\n background: white;\n background: rgba(255,255,255,0.9);\n box-shadow: 0 0 15px rgba(0,0,0,0.2);\n border-radius: 5px;\n text-align: right;\n }\n .title {\n font-size: 18pt;\n font-weight: bold;\n }\n .src {\n font-size: 10pt;\n }\n\n </style>\n\n </head>\n <body>\n\n <div id=\"map\"></div>\n\n <script>\n /* **** Leaflet **** */\n\n // Base layers\n // .. OpenStreetMap\n var osm = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {attribution: '© <a href=\"http://osm.org/copyright\">OpenStreetMap</a> contributors'});\n\n // .. CartoDB Positron\n var cartodb = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png', {attribution: '© <a href=\"http://www.openstreetmap.org/copyright\">OpenStreetMap</a> contributors, © <a href=\"http://cartodb.com/attributions\">CartoDB</a>'});\n\n // .. OSM Toner\n var toner = L.tileLayer('http://{s}.tile.stamen.com/toner/{z}/{x}/{y}.png', {attribution: 'Map tiles by <a href=\"http://stamen.com\">Stamen Design</a>, under <a href=\"http://creativecommons.org/licenses/by/3.0\">CC BY 3.0</a>. Data by <a href=\"http://openstreetmap.org\">OpenStreetMap</a>, under <a href=\"http://www.openstreetmap.org/copyright\">ODbL</a>.'});\n\n // .. White background\n var white = L.tileLayer(\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAAQMAAABmvDolAAAAA1BMVEX///+nxBvIAAAAH0lEQVQYGe3BAQ0AAADCIPunfg43YAAAAAAAAAAA5wIhAAAB9aK9BAAAAABJRU5ErkJggg==\");\n\n // Overlay layers (TMS)\n var lyr = L.tileLayer('./{z}/{x}/{y}.%(tileformat)s', {tms: true, opacity: 0.7, attribution: \"%(copyright)s\"});\n\n // Map\n var map = L.map('map', {\n center: [%(centerlon)s, %(centerlat)s],\n zoom: %(beginzoom)s,\n minZoom: %(minzoom)s,\n maxZoom: %(maxzoom)s,\n layers: [osm]\n });\n\n var basemaps = {\"OpenStreetMap\": osm, \"CartoDB Positron\": cartodb, \"Stamen Toner\": toner, \"Without background\": white}\n var overlaymaps = {\"Layer\": lyr}\n\n // Title\n var title = L.control();\n title.onAdd = function(map) {\n this._div = L.DomUtil.create('div', 'ctl title');\n this.update();\n return this._div;\n };\n title.update = function(props) {\n this._div.innerHTML = \"%(title)s\";\n };\n title.addTo(map);\n\n // Note\n var src = 'Generated by <a href=\"http://www.klokan.cz/projects/gdal2tiles/\">GDAL2Tiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>';\n var title = L.control({position: 'bottomleft'});\n title.onAdd = function(map) {\n this._div = L.DomUtil.create('div', 'ctl src');\n this.update();\n return this._div;\n };\n title.update = function(props) {\n this._div.innerHTML = src;\n };\n title.addTo(map);\n\n\n // Add base layers\n L.control.layers(basemaps, overlaymaps, {collapsed: false}).addTo(map);\n\n // Fit to overlay bounds (SW and NE points with (lat, lon))\n map.fitBounds([[%(south)s, %(east)s], [%(north)s, %(west)s]]);\n\n </script>\n\n </body>\n </html>\n\n \"\"\" % args # noqa\n\n return s","def calc_url(self):\n place = self._get_first_place()[0]\n path = \"\"\n # First see if we are in or near Sweden or Denmark\n # Change country to upper case\n location = get_main_location(self.database, place)\n country = location.get(PlaceType.COUNTRY, '').upper().strip()\n country_given = (country in MAP_NAMES_SWEDEN or \\\n country in MAP_NAMES_DENMARK) and (country != \"\")\n # if no country given, check if we might be in the vicinity defined by\n # 54 33' 0\" < lat < 66 9' 0\", 54.55 and 69.05\n # 8 3' 0\" < long < 24 9' 0\", 8.05 and 24.15 \n latitude, longitude = self._lat_lon(place)\n if latitude is None or longitude is None:\n coord_ok = False\n else:\n latitude = float(latitude) \n longitude = float(longitude)\n # Check if coordinates are inside Sweden and Denmark\n if (54.55 < latitude < 69.05) and (8.05 < longitude < 24.15):\n coord_ok = True\n else:\n msg2 = _(\"Latitude not within '54.55' to '69.05'\\n\") + \\\n _(\"Longitude not within '8.05' to '24.15'\")\n WarningDialog(_(\"Eniro map not available\"), msg2 )\n return\n\n if coord_ok:\n place_title = _build_title(self.database, place)\n place_city = _build_city(self.database, place)\n x_coord, y_coord = self._lat_lon(place, format=\"RT90\")\n # Set zoom level to 5 if Sweden/Denmark, others 3\n zoom = 5\n if not country_given:\n zoom = 3\n path = \"http://www.eniro.se/partner.fcgi?pis=1&x=%s&y=%s\" \\\n \"&zoom_level=%i&map_size=0&title=%s&city=%s&partner=gramps\"\n # Note x and y are swapped!\n path = path % (y_coord , x_coord, zoom, place_title, place_city)\n self.url = path.replace(\" \",\"%20\")\n return\n\n place_area = _build_area(self.database, place)\n if country_given and place_area:\n if country in MAP_NAMES_SWEDEN:\n path = \"http://kartor.eniro.se/query?&what=map_adr&mop=aq\" \\\n \"&geo_area=%s&partner=gramps\"\n path = path % (place_area)\n self.url = path.replace(\" \",\"%20\")\n return\n else:\n WarningDialog(_(\"Eniro map not available\"), \\\n _(\"Coordinates needed in Denmark\") )\n self.url = \"\"\n return\n\n WarningDialog(_(\"Eniro map not available\"), \n _(\"Latitude and longitude,\\n\" \\\n \"or street and city needed\") )\n return","def generate_geo_map(start_date, end_date):\n start_time = dt.datetime.now()\n\n start_date = dt.datetime.strptime(start_date.split('T')[0], '%Y-%m-%d') # Convert strings to datetime objects\n end_date = dt.datetime.strptime(end_date.split('T')[0], '%Y-%m-%d')\n\n filtered_data = filter_dataframe(df, start_date, end_date)\n dff = filtered_data\n\n traces = []\n\n data = [ dict(\n type = 'scattermapbox',\n lon = dff['lat'],\n lat = dff['lon'],\n text = dff['timestamp'],\n mode = 'markers',\n marker = dict(\n size = 8,\n opacity = 0.8,\n color = 'orange'\n ))]\n\n # relayoutData is None by default, and {'autosize': True} without relayout action\n # if main_graph_layout is not None and selector is not None and \"locked\" in selector:\n # if \"mapbox.center\" in main_graph_layout.keys():\n # lon = float(main_graph_layout[\"mapbox.center\"][\"lon\"])\n # lat = float(main_graph_layout[\"mapbox.center\"][\"lat\"])\n # zoom = float(main_graph_layout[\"mapbox.zoom\"])\n # layout[\"mapbox\"][\"center\"][\"lon\"] = lon\n # layout[\"mapbox\"][\"center\"][\"lat\"] = lat\n # layout[\"mapbox\"][\"zoom\"] = zoom\n\n print('generate_geo_map:', (dt.datetime.now()-start_time).total_seconds())\n\n figure = dict(data=data, layout=layout)\n return figure","def generate_openlayers( self ):\n\n args = {}\n args['title'] = self.options.title\n args['googlemapskey'] = self.options.googlekey\n args['yahooappid'] = self.options.yahookey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = format_extension[self.image_output.format]\n if self.image_output.format == \"PNG\":\n args['has_alpha'] = 'true'\n else:\n args['has_alpha'] = 'false'\n args['publishurl'] = \"\" if self.options.url is None else self.options.url\n args['copyright'] = self.options.copyright\n if self.options.profile in ('raster', 'gearth'):\n args['rasterzoomlevels'] = self.tmaxz+1\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\n\n s = \"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml>\"\n <head>\n <title>%(title)s</title>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n </style>\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n <script src='http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.1'></script>\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\n <script src=\"http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=%(yahooappid)s\"></script>\"\"\" % args\n\n s += \"\"\"\n <script src=\"http://www.openlayers.org/api/2.7/OpenLayers.js\" type=\"text/javascript\"></script>\n <script type=\"text/javascript\">\n var map;\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n\n // avoid pink tiles\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\n OpenLayers.Util.onImageLoadErrorColor = \"transparent\";\n\n function init(){\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n var options = {\n controls: [],\n projection: new OpenLayers.Projection(\"EPSG:900913\"),\n displayProjection: new OpenLayers.Projection(\"EPSG:4326\"),\n units: \"m\",\n maxResolution: 156543.0339,\n maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508.34)\n };\n map = new OpenLayers.Map('map', options);\n\n // create Google Mercator layers\n var gmap = new OpenLayers.Layer.Google(\"Google Streets\",\n { sphericalMercator: true, numZoomLevels: 20} );\n var gsat = new OpenLayers.Layer.Google(\"Google Satellite\",\n {type: G_SATELLITE_MAP, sphericalMercator: true, numZoomLevels: 20} );\n var ghyb = new OpenLayers.Layer.Google(\"Google Hybrid\",\n {type: G_HYBRID_MAP, sphericalMercator: true, numZoomLevels: 20});\n var gter = new OpenLayers.Layer.Google(\"Google Terrain\",\n {type: G_PHYSICAL_MAP, sphericalMercator: true, numZoomLevels: 20 });\n\n // create Virtual Earth layers\n OpenLayers.Layer.VirtualEarth.prototype.MAX_ZOOM_LEVEL=19;\n OpenLayers.Layer.VirtualEarth.prototype.RESOLUTIONS=OpenLayers.Layer.Google.prototype.RESOLUTIONS\n var veroad = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Roads\",\n {'type': VEMapStyle.Road, 'sphericalMercator': true, numZoomLevels: 20});\n var veaer = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Aerial\",\n {'type': VEMapStyle.Aerial, 'sphericalMercator': true, numZoomLevels: 20 });\n var vehyb = new OpenLayers.Layer.VirtualEarth(\"Virtual Earth Hybrid\",\n {'type': VEMapStyle.Hybrid, 'sphericalMercator': true});\n\n // create Yahoo layer\n var yahoo = new OpenLayers.Layer.Yahoo(\"Yahoo Street\",\n {'sphericalMercator': true});\n var yahoosat = new OpenLayers.Layer.Yahoo(\"Yahoo Satellite\",\n {'type': YAHOO_MAP_SAT, 'sphericalMercator': true});\n var yahoohyb = new OpenLayers.Layer.Yahoo(\"Yahoo Hybrid\",\n {'type': YAHOO_MAP_HYB, 'sphericalMercator': true});\n\n // create OSM/OAM layer\n var osm = new OpenLayers.Layer.TMS( \"OpenStreetMap\",\n \"http://tile.openstreetmap.org/\",\n { type: 'png', getURL: osm_getTileURL, displayOutsideMaxExtent: true,\n attribution: '<a href=\"http://www.openstreetmap.org/\">OpenStreetMap</a>'} );\n var oam = new OpenLayers.Layer.TMS( \"OpenAerialMap\",\n \"http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/\",\n { type: 'png', getURL: osm_getTileURL } );\n\n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.TMS( \"TMS Overlay\", \"\",\n { // url: '', serviceVersion: '.', layername: '.',\n type: '%(tileformat)s', getURL: overlay_getTileURL, alpha: %(has_alpha)s,\n isBaseLayer: false\n });\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\n\n map.addLayers([gmap, gsat, ghyb, gter, veroad, veaer, vehyb,\n yahoo, yahoosat, yahoohyb, osm, oam,\n tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );\n \"\"\" % args\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n var options = {\n controls: [],\n projection: new OpenLayers.Projection(\"EPSG:4326\"),\n maxResolution: 0.703125,\n maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90)\n };\n map = new OpenLayers.Map('map', options);\n\n layer = new OpenLayers.Layer.WMS( \"Blue Marble\",\n \"http://labs.metacarta.com/wms-c/Basic.py?\", {layers: 'satellite' } );\n map.addLayer(layer);\n wms = new OpenLayers.Layer.WMS( \"VMap0\",\n \"http://labs.metacarta.com/wms-c/Basic.py?\", {layers: 'basic', format: 'image/png' } );\n map.addLayer(wms);\n\n var tmsoverlay = new OpenLayers.Layer.TMS( \"TMS Overlay\", \"\",\n {\n serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\n type: '%(tileformat)s', getURL: overlay_getTileURL,\n isBaseLayer: false\n });\n map.addLayer(tmsoverlay);\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent( mapBounds );\n \"\"\" % args\n\n elif self.options.profile in ('raster', 'gearth'):\n s += \"\"\"\n var options = {\n controls: [],\n maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),\n maxResolution: %(rastermaxresolution)f,\n numZoomLevels: %(rasterzoomlevels)d\n };\n map = new OpenLayers.Map('map', options);\n\n var layer = new OpenLayers.Layer.TMS( \"TMS Layer\",\"\",\n { url: '', serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\n type: '%(tileformat)s', getURL: overlay_getTileURL\n });\n map.addLayer(layer);\n map.zoomToExtent( mapBounds );\n \"\"\" % args\n\n\n s += \"\"\"\n map.addControl(new OpenLayers.Control.PanZoomBar());\n map.addControl(new OpenLayers.Control.MousePosition());\n map.addControl(new OpenLayers.Control.MouseDefaults());\n map.addControl(new OpenLayers.Control.KeyboardDefaults());\n }\n \"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n function osm_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n var limit = Math.pow(2, z);\n\n if (y < 0 || y >= limit) {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n } else {\n x = ((x %% limit) + limit) %% limit;\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n }\n }\n\n function overlay_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n if (this.map.baseLayer.name == 'Virtual Earth Roads' || this.map.baseLayer.name == 'Virtual Earth Aerial' || this.map.baseLayer.name == 'Virtual Earth Hybrid') {\n z = z + 1;\n }\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom ) {\n //console.log( this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type);\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n function overlay_getTileURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom) {\n // console.log( this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type);\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n elif self.options.profile in ('raster','gearth'):\n s += \"\"\"\n function overlay_getTileURL(bounds) {\n var res = this.map.getResolution();\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.maxExtent.bottom) / (res * this.tileSize.h));\n var z = this.map.getZoom();\n if (x >= 0 && y >= 0) {\n return this.url + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n } else {\n return \"https://github.com/mj10777/mapmbtiles/img/none.png\";\n }\n }\n \"\"\" % args\n\n s += \"\"\"\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n if (map.updateSize) { map.updateSize(); };\n }\n\n onresize=function(){ resize(); };\n\n </script>\n </head>\n <body onload=\"init()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"https://github.com/mj10777/mapmbtiles\">MapMbTiles</a>/<a href=\"http://www.klokan.cz/projects/gdal2mbtiles/\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n <script type=\"text/javascript\" >resize()</script>\n </body>\n </html>\"\"\" % args\n\n return s","def build_url(self):\n return self.data_url.format(latitude=self.latitude, longitude=self.longitude)","def map_link(self):\n return self.map_url.format(latitude=self.latitude, longitude=self.longitude)","def build_url(ori_lon, ori_lat, des_lon, des_lat, year, month, day, hour, minute, args={}):\n options = dict()\n with open(option_file, 'r', newline='') as file:\n # Read the options file\n for line in file:\n if line[0] == '#': # if the first character of a line is '#' skip it\n continue\n splited_line = line.rstrip().split(':')\n if len(splited_line) < 2: # if it is a line with no ':'\n continue\n options[splited_line[0]] = splited_line[1]\n base_URL = 'localhost:' + port + '/otp/routers/default/plan'\n fromPlace = ori_lon + ',' + ori_lat\n toPlace = des_lon + ',' + des_lat\n date = year + '/' + month + '/' + day\n time = hour + ':' + minute + ':00'\n\n url = 'http://' + base_URL + '?fromPlace=' + fromPlace + '&toPlace=' + toPlace + '&date=' + date + '&time=' + time\n for option_name in options.keys():\n option = options[option_name]\n url += '&' + option_name + '=' + option\n if not 'mode' in url:\n url += '&mode=TRANSIT,WALK'\n for key in args.keys():\n url+= '&' + key + '=' + args[key]\n\n return url","def map():\n return render_template('map.html')","def visualize(g):\n url = \"http://www.gcmap.com/mapui?P=\"\n routes = []\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n route = (g.city_dict[key].get_code(), flight[0])\n if(route not in routes):\n routes.append(route)\n \n for flight in routes:\n url = url + flight[0] + \"-\" + flight[1]\n url = url + \",+\"\n \n url = url[:-2]\n return url","def map():\n\n return render_template(\"map.html\")","def mobilize_map_url(value, args=None):\n url = value\n # url = value.replace(\"maps.google.com\", 'm.google.com')\n return url # + \"&source=mobilesearchapp\"","def write_prefix(self, lat, lon):\n # Open the Maps API and center at the mean of the data\n self.fd.write(\"\"\"<!DOCTYPE html>\n <html>\n <head>\n <meta name=\"viewport\" content=\"initial-scale=1.0, user-scalable=no\" />\n <style type=\"text/css\">\n html { height: 100%% }\n body { height: 100%%; margin: 0px; padding: 0px }\n </style>\n <script type=\"text/javascript\"\n src=\"http://maps.google.com/maps/api/js?sensor=false\">\n </script>\n <script type=\"text/javascript\">\n function initialize() {\n var myLatlng = new google.maps.LatLng(%f, %f);\n var myOptions = {\n zoom: 14,\n center: myLatlng,\n mapTypeId: google.maps.MapTypeId.ROADMAP\n }\n var map = new google.maps.Map(document.getElementById(\"map_canvas\"), myOptions);\n var infowindow = new google.maps.InfoWindow({\n content: 'No EXIF Data'\n });\n var contentStrings = {}\n \"\"\" % (lat, lon))","def walking():\r\n name = request.args[\"address\"]\r\n end_name=request.args[\"end_point\"]\r\n end_lng = request.args[\"end_lng\"]\r\n end_lat = request.args[\"end_lat\"]\r\n end_lng = float(end_lng)\r\n end_lat = float(end_lat)\r\n start_lng=get_address(name)[1]\r\n start_lat=get_address(name)[0]\r\n\r\n\r\n #get coordinates of start and end point\r\n map_directions, geojson_str = get_static_map(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n logging.warning(\"Map directions %s\", str(map_directions))\r\n\r\n\r\n #retrieve instructions\r\n instructions = get_map_instructions(\r\n start_lng=start_lng,\r\n start_lat=start_lat,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n )\r\n\r\n\r\n # generate interactive map\r\n return render_template(\r\n \"page4.html\",\r\n mapbox_token=MAPBOX_TOKEN,\r\n geojson_str=geojson_str,\r\n end_name=end_name,\r\n name=name,\r\n start_lng=start_lng,\r\n start_lat=start_lng,\r\n end_lng=end_lng,\r\n end_lat=end_lat,\r\n center_lng=(start_lng + end_lng) / 2,\r\n center_lat=(start_lat + end_lat) / 2,\r\n instructions=instructions,\r\n method = 'Walking'\r\n )","def plot_gps_html(gps_list):\n import gmplot\n import matplotlib as mpl\n import vtool as vt\n\n import wbia.plottool as pt\n\n pt.qt4ensure()\n\n lat = gps_list.T[0]\n lon = gps_list.T[1]\n\n # Get extent of\n bbox = vt.bbox_from_verts(gps_list)\n centerx, centery = vt.bbox_center(bbox)\n\n gmap = gmplot.GoogleMapPlotter(centerx, centery, 13)\n color = mpl.colors.rgb2hex(pt.ORANGE)\n gmap.scatter(lat, lon, color=color, size=100, marker=False)\n gmap.draw('mymap.html')\n ut.startfile('mymap.html')\n\n # # Scale\n # bbox = vt.scale_bbox(bbox, 10.0)\n # extent = vt.extent_from_bbox(bbox)\n # basemap_extent = dict(llcrnrlon=extent[2], urcrnrlon=extent[3],\n # llcrnrlat=extent[0], urcrnrlat=extent[1])\n # # Whole globe\n # #basemap_extent = dict(llcrnrlon=0, llcrnrlat=-80,\n # # urcrnrlon=360, urcrnrlat=80)\n\n # from mpl_toolkits.basemap import Basemap\n # from matplotlib.colors import LightSource # NOQA\n # from mpl_toolkits.basemap import shiftgrid, cm # NOQA\n # from netCDF4 import Dataset\n # # Read information to make background pretty\n # logger.info('Grab topo information')\n # etopodata = Dataset('http://ferret.pmel.noaa.gov/thredds/dodsC/data/PMEL/etopo5.nc')\n # logger.info('Read topo information')\n # topoin = etopodata.variables['ROSE'][:]\n # lons = etopodata.variables['ETOPO05_X'][:]\n # lats = etopodata.variables['ETOPO05_Y'][:]\n # # shift data so lons go from -180 to 180 instead of 20 to 380.\n # logger.info('Shift data')\n # topoin, lons = shiftgrid(180., topoin, lons, start=False)\n\n # logger.info('Make figure')\n # fnum = pt.ensure_fnum(None)\n # fig = pt.figure(fnum=fnum, doclf=True, docla=True) # NOQA\n # logger.info('Draw projection')\n # m = Basemap(projection='mill', **basemap_extent)\n # # setup Lambert Conformal basemap.\n # #m = Basemap(projection='cea',resolution='h', **basemap_extent)\n\n # # transform to nx x ny regularly spaced 5km native projection grid\n # logger.info('projection grid')\n # nx = int((m.xmax - m.xmin) / 5000.) + 1\n # ny = int((m.ymax - m.ymin) / 5000.) + 1\n # topodat = m.transform_scalar(topoin, lons, lats, nx, ny)\n\n # # plot image over map with imshow.\n # im = m.imshow(topodat, cm.GMT_haxby) # NOQA\n # # draw coastlines and political boundaries.\n # m.drawcoastlines()\n # m.drawcountries()\n # m.drawstates()\n\n # transform to nx x ny regularly spaced 5km native projection grid\n # ls = LightSource(azdeg=90, altdeg=20)\n # rgb = ls.shade(topodat, cm.GMT_haxby)\n # im = m.imshow(rgb)\n # draw coastlines and political boundaries.\n\n # m.drawcoastlines()\n # m.drawcountries()\n # m.drawstates()\n\n # draw a boundary around the map, fill the background.\n # this background will end up being the ocean color, since\n # the continents will be drawn on top.\n # m.bluemarble()\n # m.drawmapboundary(fill_color='aqua')\n # m.fillcontinents(color='coral', lake_color='aqua')\n # Convert GPS to projected coordinates\n # x1, y1 = m(lon, lat) # convert to meters # lon==X, lat==Y\n # m.plot(x1, y1, '*', markersize=10)\n # fig.zoom_fac = pt.zoom_factory()\n # fig.pan_fac = pt.pan_factory()\n # fig.show()","def map_image(res):\n # constants\n MAP_URL = \"https://maps.googleapis.com/maps/api/staticmap\"\n SIZE = \"400x400\"\n\n polygon_path = mh.get_polygon_path(res)\n origin = mh.get_latlon(mh.get_origin(res))\n destination = mh.get_latlon(mh.get_destination(res))\n params = {\n \"size\": SIZE,\n \"path\": f\"enc:{polygon_path}\",\n \"markers\": [f\"color:red|label:X|{destination}\", f\"size:small|color:blue|{origin}\"],\n \"key\": key\n }\n img_resp = requests.get(url=MAP_URL, params=params)\n return img_resp.url","def download_map(latitude, longitude, outname):\n url1 = \"https://maps.googleapis.com/maps/api/staticmap?center={:.8f},{:.8f}&zoom=8&maptype=satellite&size=1000x1000&scale=4\".format(latitude,longitude)\n buffer1 = StringIO(urllib.urlopen(url1).read())\n image = Image.open(buffer1)\n image.save('{}.png'.format(outname))","def map_locations(args, number_publications, numbers,\n links_locations_and_timestamps, gps_coordinates,\n countrycodes_for_js, continents_for_js):\n templateLoader = jinja2.FileSystemLoader(searchpath=\"./\")\n templateEnv = jinja2.Environment(loader=templateLoader)\n template = templateEnv.get_template(\"template.html\")\n outputText = template.render(\n target_account=args.target_account,\n publications_number=number_publications,\n retrieved_number=len(links_locations_and_timestamps),\n mapped_number=numbers[0],\n links=str([x[0] for x in links_locations_and_timestamps]),\n errors_number=len(links_locations_and_timestamps) - numbers[0],\n places=str([x[1] for x in links_locations_and_timestamps]),\n timestamps=str([x[2] for x in links_locations_and_timestamps]),\n locations=str(gps_coordinates),\n countrycodes=str(countrycodes_for_js),\n continents=str(continents_for_js))\n\n with open(\n \"output/\" + args.target_account + \"/\" + args.target_account +\n \"_instaloctrack_map.html\", \"w\") as f:\n f.write(outputText)\n f.close()\n print(Fore.WHITE + \"Map with all the markers was written to:\" +\n Fore.GREEN + \" output/\" + args.target_account + \"/\" +\n args.target_account + \"_instaloctrack_map.html\")","def generate_garmin_kml(self, d ):\n return (\"\"\"\n <GroundOverlay>\n <Icon>\n <href>%(image_url)s</href>\n <DrawOrder>%(draw_order)d</DrawOrder>\n </Icon>\n <LatLonBox>\n <north>%(north).14f</north>\n <south>%(south).14f</south>\n <east>%(east).14f</east>\n <west>%(west).14f</west>\n </LatLonBox>\n </GroundOverlay>\"\"\" % d )","def get_map_instructions(start_lng, start_lat, end_lng, end_lat):\r\n directions_resp = requests.get(\r\n f\"https://api.mapbox.com/directions/v5/mapbox/walking/{start_lng},{start_lat};{end_lng},{end_lat}\",\r\n params={\r\n \"access_token\": MAPBOX_TOKEN,\r\n \"geometries\": \"geojson\",\r\n \"steps\": \"true\",\r\n \"alternatives\": \"true\",\r\n },\r\n )\r\n instructions=[]\r\n for step in directions_resp.json()['routes'][0]['legs'][0]['steps']:\r\n instructions.append(f\"{step['maneuver']['instruction']}\")\r\n #listToStr = '<br>'.join(map(str, instruction))\r\n return instructions","def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\n\n lat_grid = np.linspace(latS, latN, latlen)\n lon_grid = np.linspace(lonW, lonE, lonlen)\n\n return lat_grid,lon_grid","def map_page():\n m = Map() # Create map html\n return render_template('index.html') # pulls map html using jinja2","def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\n width, height = 256 * wTileN, 256 * hTileN\n map_img = Image.new('RGB', (width, height))\n for x in range(0, wTileN):\n for y in range(0, hTileN):\n url = 'https://mt0.google.com/vt?x=' + \\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\n current_tile = str(x)+'-'+str(y)\n urllib.request.urlretrieve(url, current_tile)\n map_img.paste(Image.open(current_tile), (x*256, y*256))\n os.remove(current_tile)\n return map_img","def _makeimap(self):\n self.map_[\"source\"] = \"nasa\"\n self.map_[\"instrument\"] = \"goes\"\n self.map_[\"physobs\"] = \"irradiance\"\n self.map_[\"provider\"] = \"sdac\"","def maps(request):\n #convert image locations to google maps parsable points\n now = datetime.utcnow().replace(tzinfo=utc)\n latlngs = search_utils.filter_date(search_utils.min_date, now)\n points = [search_utils.to_map_point(image) for image in latlngs]\n #load the search form sidebar\n t = loader.get_template(\"wainz/search_form.html\")\n ctx = Context({})\n search_form = t.render(ctx)\n\n return render_to_response('wainz/maps.html', {\"latLngs\":points, \"search_form\":search_form, \"typeAheadTags\":Tag.objects.all()}, context_instance = RequestContext(request))","def start_google_map_header(outfile: TextIO) -> None:\n outfile.write(\" <script type=\\\"text/javascript\\\"\\n\")\n outfile.write(\" src=\\\"https://maps.googleapis.com/maps/api/js?\"\n \"key=AIzaSyAaITaFdh_own-ULkURNKtyeh2ZR_cpR74&sensor=false\\\">\\n\")\n outfile.write(\" </script>\\n\")\n outfile.write(\" <script type=\\\"text/javascript\\\">\\n\")\n outfile.write(\" function initialize() {\\n\")\n outfile.write(\" var mapOptions = {\\n\")\n outfile.write(\" center: new google.maps.LatLng(0,0),\\n\")\n outfile.write(\" zoom: 1,\\n\")\n outfile.write(\" disableDefaultUI: true,\\n\")\n outfile.write(\" panControl: false,\\n\")\n outfile.write(\" zoomControl: true,\\n\")\n outfile.write(\" mapTypeControl: true,\\n\")\n outfile.write(\" scaleControl: false,\\n\")\n outfile.write(\" streetViewControl: false,\\n\")\n outfile.write(\" overviewMapControl: false,\\n\")\n outfile.write(\" mapTypeId: google.maps.MapTypeId.TERRAIN\\n\")\n outfile.write(\" };\\n\")","def warp(self):\n if not self.url or not self.sourceSRS:\n return\n self.map = mapscript.mapObj()\n self.map.setSize(int(self.url.getArgument(\"width\")),int(self.url.getArgument(\"height\")))\n (minx,miny,maxx,maxy) = map(lambda x: float(x), self.url.getArgument(\"bbox\").split(\",\"))\n self.map.extent = mapscript.rectObj(minx,miny,maxx,maxy)\n self.map.web.imagepath=tempfile.mkdtemp()\n self.map.setProjection(self.targetSRS.__str__())\n self.layer = mapscript.layerObj(self.map)\n self.layer.type = mapscript.MS_LAYER_RASTER\n self.layer.connection = self.url.getConnection()\n self.layer.status = mapscript.MS_DEFAULT\n self.layer.setConnectionType(mapscript.MS_WMS,None)\n self.layer.setMetaData(\"wms_srs\",self.sourceSRS.__str__())\n self.layer.setMetaData(\"wms_name\", self.url.getArgument(\"layers\"))\n self.layer.setMetaData(\"wms_server_version\",self.url.getArgument(\"version\"))\n\n # WMS 1.3.0 is not supported by MapServer < 6.0 \n # http://trac.osgeo.org/mapserver/ticket/3039\n if self.url.getArgument(\"version\") == \"1.3.0\":\n self.layer.setMetaData(\"wms_server_version\",\"1.1.1\")\n \n if self.sourceSRS.authority == \"CRS\" and self.sourceSRS.code == \"84\":\n self.layer.setMetaData(\"wms_srs\",\"EPSG:4326\")\n \n\n self.layer.setMetaData(\"wms_exceptions_format\",self.url.getArgument(\"exceptions\"))\n self.layer.setMetaData(\"wms_formatlist\",self.url.getArgument(\"format\"))\n self.layer.setMetaData(\"wms_style\",self.url.getArgument(\"style\"))\n self.layer.setMetaData(\"wms_transparent\",self.url.getArgument(\"transparent\"))\n self.layer.setProjection(self.sourceSRS.__str__())\n self.layer.debug = 5\n\n if self.url.getArgument(\"format\") == \"image/png\":\n self.map.outputformat.imagemode = mapscript.MS_IMAGEMODE_RGBA\n if self.url.getArgument(\"format\") == \"image/jpg\":\n self.layer.setMetaData(\"wms_formatlist\",\"image/jpeg\")\n self.map.selectOutputFormat(\"image/jpeg\")\n else:\n self.map.selectOutputFormat(self.url.getArgument(\"format\"))\n self.map.outputformat.transparent= 1\n\n try:\n # draw the map\n #self.map.save(\"/tmp/pokus2.map\")\n image = self.map.draw()\n if image:\n return image\n except :\n\n # something failed during the layer drawing. try to print the\n # error to stderr as well as generate new image with the error\n # message\n exc_type, exc_value, exc_traceback = sys.exc_info()\n traceback.print_exc(file=sys.stderr)\n traceback.print_tb(exc_traceback, limit=1, file=sys.stderr)\n\n self.map.removeLayer(0)\n self.map.setFontSet(os.path.join(os.path.abspath(os.path.dirname(__file__)),\"fonts.txt\"))\n self.map.outputformat.transparent= 0\n\n self.layer = mapscript.layerObj(self.map)\n self.layer.type = mapscript.MS_LAYER_ANNOTATION\n #self.layer.transform = mapscript.MS_OFF\n\n line = mapscript.lineObj()\n line.add(mapscript.pointObj(minx+(maxx-minx)/2.,miny+(maxy-miny)/2.))\n feature = mapscript.shapeObj()\n feature.add(line)\n self.layer.addFeature(feature)\n self.layer.labelcache = mapscript.MS_TRUE\n \n\n classobj = mapscript.classObj(self.layer)\n text = \"\"\n \n ## try to guess, where the problem is\n for i in textwrap.wrap(str(exc_value),70):\n text += i+\"\\n\"\n classobj.setText(text)\n\n classobj.label.font = \"sans\"\n classobj.label.type = mapscript.MS_TRUETYPE\n classobj.label.antialias = mapscript.MS_FALSE\n classobj.label.size = 12\n classobj.label.position = mapscript.MS_CC\n #classobj.label.partials = mapscript.MS_FALSE\n classobj.label.force = mapscript.MS_TRUE\n\n\n self.layer.status = mapscript.MS_ON\n #self.map.save(\"/tmp/pokus3.map\")\n image = self.map.draw()\n return image","def create_url(page_num, start_time, end_time, search_term):\r\n \"\"\"timestamp format: \\d\\d\\d\\d.\\d\\d.\\d\\d\"\"\" #2020.01.01 #新增 確診\r\n base=\"https://www.cdc.gov.tw/Bulletin/List/MmgtpeidAR5Ooai4-fgHzQ\"\r\n url = base + \"?page=\" + str(page_num) + \"&startTime=\" + str(start_time) + \"&endTime=\" + str(end_time) + \"&keyword=\" + str(search_term)\r\n return url","def generate_openlayers(self):\n\n args = {}\n args['title'] = self.options.title\n args['bingkey'] = self.options.bingkey\n args['south'], args['west'], args['north'], args['east'] = self.swne\n args['minzoom'] = self.tminz\n args['maxzoom'] = self.tmaxz\n args['tilesize'] = self.tilesize\n args['tileformat'] = self.tileext\n args['publishurl'] = self.options.url\n args['copyright'] = self.options.copyright\n if self.options.tmscompatible:\n args['tmsoffset'] = \"-1\"\n else:\n args['tmsoffset'] = \"\"\n if self.options.profile == 'raster':\n args['rasterzoomlevels'] = self.tmaxz+1\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\n\n s = r\"\"\"<!DOCTYPE html PUBLIC \"-//W3C//DTD XHTML 1.0 Strict//EN\" \"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\">\n <html xmlns=\"http://www.w3.org/1999/xhtml\"\n <head>\n <title>%(title)s</title>\n <meta http-equiv='imagetoolbar' content='no'/>\n <style type=\"text/css\"> v\\:* {behavior:url(#default#VML);}\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\n body { margin: 10px; background: #fff; }\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\n #map { height: 95%%; border: 1px solid #888; }\n .olImageLoadError { display: none; }\n .olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }\n </style>\"\"\" % args # noqa\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n <script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>\n \"\"\" % args\n\n s += \"\"\"\n <script src=\"http://www.openlayers.org/api/2.12/OpenLayers.js\"></script>\n <script>\n var map;\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\n var mapMinZoom = %(minzoom)s;\n var mapMaxZoom = %(maxzoom)s;\n var emptyTileURL = \"http://www.maptiler.org/img/none.png\";\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\n\n function init(){\"\"\" % args\n\n if self.options.profile == 'mercator':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n projection: \"EPSG:3857\",\n displayProjection: new OpenLayers.Projection(\"EPSG:4326\"),\n numZoomLevels: 20\n };\n map = new OpenLayers.Map(options);\n\n // Create Google Mercator layers\n var gmap = new OpenLayers.Layer.Google(\"Google Streets\",\n {\n type: google.maps.MapTypeId.ROADMAP,\n sphericalMercator: true\n });\n var gsat = new OpenLayers.Layer.Google(\"Google Satellite\",\n {\n type: google.maps.MapTypeId.SATELLITE,\n sphericalMercator: true\n });\n var ghyb = new OpenLayers.Layer.Google(\"Google Hybrid\",\n {\n type: google.maps.MapTypeId.HYBRID,\n sphericalMercator: true\n });\n var gter = new OpenLayers.Layer.Google(\"Google Terrain\",\n {\n type: google.maps.MapTypeId.TERRAIN,\n sphericalMercator: true\n });\n\n // Create Bing layers\n var broad = new OpenLayers.Layer.Bing({\n name: \"Bing Roads\",\n key: \"%(bingkey)s\",\n type: \"Road\",\n sphericalMercator: true\n });\n var baer = new OpenLayers.Layer.Bing({\n name: \"Bing Aerial\",\n key: \"%(bingkey)s\",\n type: \"Aerial\",\n sphericalMercator: true\n });\n var bhyb = new OpenLayers.Layer.Bing({\n name: \"Bing Hybrid\",\n key: \"%(bingkey)s\",\n type: \"AerialWithLabels\",\n sphericalMercator: true\n });\n\n // Create OSM layer\n var osm = new OpenLayers.Layer.OSM(\"OpenStreetMap\");\n\n \"\"\" % args # noqa\n\t\t \n if self.options.xyz:\n s += \"\"\"\t\t \n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.XYZ(\"XYZ Overlay\",\n \"${z}/${x}/${y}.png\", {\n transitionEffect: 'resize',\n isBaseLayer: false\n });\n\t\t\t\t \n\t\t \"\"\" % args # noqa\n else:\n s += \"\"\"\t\t \n // create TMS Overlay layer\n var tmsoverlay = new OpenLayers.Layer.TMS(\"TMS Overlay\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n isBaseLayer: false,\n getURL: getURL\n });\n\t\t\t\t \n\t\t \"\"\" % args # noqa\t\t \n\t\t \n s += \"\"\" \n if (OpenLayers.Util.alphaHack() == false) {\n tmsoverlay.setOpacity(0.7);\n }\n\n map.addLayers([gmap, gsat, ghyb, gter,\n broad, baer, bhyb,\n osm, tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent(mapBounds.transform(map.displayProjection, map.projection));\n \"\"\" % args # noqa\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n projection: \"EPSG:4326\"\n };\n map = new OpenLayers.Map(options);\n\n var wms = new OpenLayers.Layer.WMS(\"VMap0\",\n \"http://tilecache.osgeo.org/wms-c/Basic.py?\",\n {\n layers: 'basic',\n format: 'image/png'\n }\n );\n var tmsoverlay = new OpenLayers.Layer.TMS(\"TMS Overlay\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n isBaseLayer: false,\n getURL: getURL\n });\n if (OpenLayers.Util.alphaHack() == false) {\n tmsoverlay.setOpacity(0.7);\n }\n\n map.addLayers([wms,tmsoverlay]);\n\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\n map.addControl(switcherControl);\n switcherControl.maximizeControl();\n\n map.zoomToExtent(mapBounds);\n \"\"\" % args # noqa\n\n elif self.options.profile == 'raster':\n s += \"\"\"\n var options = {\n div: \"map\",\n controls: [],\n maxExtent: new OpenLayers.Bounds(%(west)s, %(south)s, %(east)s, %(north)s),\n maxResolution: %(rastermaxresolution)f,\n numZoomLevels: %(rasterzoomlevels)d\n };\n map = new OpenLayers.Map(options);\n\n var layer = new OpenLayers.Layer.TMS(\"TMS Layer\", \"\",\n {\n serviceVersion: '.',\n layername: '.',\n alpha: true,\n type: '%(tileformat)s',\n getURL: getURL\n });\n\n map.addLayer(layer);\n map.zoomToExtent(mapBounds);\n \"\"\" % args # noqa\n\n s += \"\"\"\n map.addControls([new OpenLayers.Control.PanZoomBar(),\n new OpenLayers.Control.Navigation(),\n new OpenLayers.Control.MousePosition(),\n new OpenLayers.Control.ArgParser(),\n new OpenLayers.Control.Attribution()]);\n }\n \"\"\" % args\n\n if self.options.profile == 'mercator' and self.options.xyz is None:\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom();\n if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {\n z+=1;\n }\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n elif self.options.profile == 'geodetic':\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom()%(tmsoffset)s;\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n elif self.options.profile == 'raster':\n s += \"\"\"\n function getURL(bounds) {\n bounds = this.adjustBounds(bounds);\n var res = this.getServerResolution();\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\n var z = this.getServerZoom();\n var path = this.serviceVersion + \"/\" + this.layername + \"/\" + z + \"/\" + x + \"/\" + y + \".\" + this.type;\n var url = this.url;\n if (OpenLayers.Util.isArray(url)) {\n url = this.selectUrl(path, url);\n }\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\n return url + path;\n } else {\n return emptyTileURL;\n }\n }\n \"\"\" % args # noqa\n\n s += \"\"\"\n function getWindowHeight() {\n if (self.innerHeight) return self.innerHeight;\n if (document.documentElement && document.documentElement.clientHeight)\n return document.documentElement.clientHeight;\n if (document.body) return document.body.clientHeight;\n return 0;\n }\n\n function getWindowWidth() {\n if (self.innerWidth) return self.innerWidth;\n if (document.documentElement && document.documentElement.clientWidth)\n return document.documentElement.clientWidth;\n if (document.body) return document.body.clientWidth;\n return 0;\n }\n\n function resize() {\n var map = document.getElementById(\"map\");\n var header = document.getElementById(\"header\");\n var subheader = document.getElementById(\"subheader\");\n map.style.height = (getWindowHeight()-80) + \"px\";\n map.style.width = (getWindowWidth()-20) + \"px\";\n header.style.width = (getWindowWidth()-20) + \"px\";\n subheader.style.width = (getWindowWidth()-20) + \"px\";\n if (map.updateSize) { map.updateSize(); };\n }\n\n onresize=function(){ resize(); };\n\n </script>\n </head>\n <body onload=\"init()\">\n <div id=\"header\"><h1>%(title)s</h1></div>\n <div id=\"subheader\">Generated by <a href=\"http://www.klokan.cz/projects/gdal2tiles/\">GDAL2Tiles</a>, Copyright © 2008 <a href=\"http://www.klokan.cz/\">Klokan Petr Pridal</a>, <a href=\"http://www.gdal.org/\">GDAL</a> & <a href=\"http://www.osgeo.org/\">OSGeo</a> <a href=\"http://code.google.com/soc/\">GSoC</a>\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\n </div>\n <div id=\"map\"></div>\n <script type=\"text/javascript\" >resize()</script>\n </body>\n </html>\"\"\" % args # noqa\n\n return s","def test_url_helper_coordinates():\n urlh = URLHelper()\n args = []\n kwargs = {\"coordinates\": \"210.80242917 54.348753\"}\n url = urlh.build_url(*args, **kwargs)\n assert url == \"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/ra=210.802429/dec=54.348753\"","def create_url(_origin_details, travel_start_date, travel_start_time, destination_list):\n prefix = 'https://timetable.search.ch/api/route.json?one_to_many=1'\n\n origin_body = f'&from={_origin_details}&date={travel_start_date}&time={travel_start_time}'\n\n # Build iteratively with necessary syntax between destinations\n destination_body = ''\n for i, dest in enumerate(destination_list):\n destination_body = f'{destination_body}&to[{i}]={dest}'\n\n return f'{prefix}{origin_body}{destination_body}'","def generate_lookat_kml_block(self, lng, lat, viewrange):\n return \"\"\"\n <LookAt>\n <longitude>%.14f</longitude>\n <latitude>%.14f</latitude>\n <altitude>0</altitude>\n <range>%.f</range>\n <tilt>0</tilt>\n <heading>0</heading>\n </LookAt>\n\"\"\" % (lng, lat, viewrange)","def generateMarkers(self, *args, **kwargs): \n return 'var PloneMapMarkers = [' + \\\n ''.join([\"{'type': '%s','options': { 'position': new google.maps.LatLng( %s, %s ), 'title' : '%s', 'title_' : '%s' }},\" \n % (object.markerIcon, object.latitude, object.longitude, object.Title(), object.getId()) \n for object in self.context.objectValues() \n if hasattr(object, 'latitude') and len(object.latitude) > 0 ])[:-1] \\\n + '];'","def decorateMap(mapObj, startxy):\n\n startx, starty = startxy # Syntactic sugar\n\n # Copy the map object so we don't modify the original passed\n # TODO: Copy!\n mapObjCopy = mapObj[:]\n\n # Remove the non-wall characters from the map data\n for x in range(len(mapObjCopy)):\n for y in range(len(mapObjCopy[0])):\n if mapObjCopy[x][y] in ('$', '.', '@', '+', '*'):\n mapObjCopy[x][y] = ' '\n\n # Flood fill to determine inside/outside floor tiles.\n floodFill(mapObjCopy, startx, starty, ' ', 'o')\n\n # Convert the adj8oined walls into corner tiles.\n for x in range(len(mapObjCopy)):\n for y in range(len(mapObjCopy[0])):\n\n if mapObjCopy[x][y] == '#':\n if (isWall(mapObjCopy, x, y-1) and isWall(mapObjCopy, x+1, y)) or \\\n (isWall(mapObjCopy, x+1, y) and isWall(mapObjCopy, x, y+1)) or \\\n (isWall(mapObjCopy, x, y+1) and isWall(mapObjCopy, x-1, y)) or \\\n (isWall(mapObjCopy, x-1, y) and isWall(mapObjCopy, x, y-1)):\n mapObjCopy[x][y] = 'x'\n\n elif mapObjCopy[x][y] == ' ' and random.randint(0, 99) < OUTSIDE_DECORATION_PCT:\n mapObjCopy[x][y] = random.choice(list(OUTSIDEDECOMAPPING.keys()))\n\n return mapObjCopy","def generate_link_kml(self, d):\n return \"\"\"\\\n <NetworkLink>\n <name>%(image_filename)s</name>\n <Region>\n <Lod>\n <minLodPixels>%(minlodpixels)d</minLodPixels>\n <maxLodPixels>-1</maxLodPixels>\n </Lod>\n <LatLonAltBox>\n <north>%(north).14f</north>\n <south>%(south).14f</south>\n <east>%(east).14f</east>\n <west>%(west).14f</west>\n </LatLonAltBox>\n </Region>\n <Link>\n <href>%(link_url)s</href>\n <viewRefreshMode>onRegion</viewRefreshMode>\n </Link>\n </NetworkLink>\"\"\" % d","def _show_map(service_code=None, reverse=None, atco_code=None, coords=None):\n if atco_code is not None:\n stop = models.StopPoint.query.get(atco_code.upper())\n if stop is None:\n raise NotFound(\n Markup(\"Stop with code <strong>{}</strong> does not exist.\")\n .format(atco_code)\n )\n else:\n stop = None\n\n if service_code is not None:\n sv = (\n models.Service.query\n .options(db.joinedload(models.Service.patterns))\n .filter(models.Service.code == service_code)\n .one_or_none()\n )\n if sv is None:\n raise NotFound(\n Markup(\"Service <strong>{}</strong> does not exist.\")\n .format(service_code)\n )\n is_reverse, _ = sv.has_mirror(reverse)\n else:\n sv = None\n is_reverse = None\n\n # TODO: Add redirect for incorrect capitalisation, etc\n\n # Quick check to ensure coordinates are within range of Great Britain\n if coords is not None and location.check_bounds(coords[0], coords[1]):\n latitude, longitude, zoom = coords\n else:\n latitude, longitude, zoom = None, None, None\n\n return render_template(\"map.html\", latitude=latitude, longitude=longitude,\n zoom=zoom, stop=stop, service=sv, reverse=is_reverse)","def write_location_page(outfile: TextIO, do_print: bool, loc: TMB_Classes.LocationClass, point_locations: dict,\n location_species: dict, location_bi_names: dict, location_sp_names: dict,\n location_direct_refs: dict, location_cited_refs: dict, references: list,\n locations_range_species: dict, location_keys: Optional[dict]) -> None:\n\n def format_latlon(lat: float, lon: float) -> str:\n \"\"\"\n subfunction to format a lat,lon pair for printing\n \"\"\"\n if lat < 0:\n latdir = \"S\"\n else:\n latdir = \"N\"\n if lon < 0:\n londir = \"W\"\n else:\n londir = \"E\"\n return \"{:1.6f}°{}, {:1.6f}°{}\".format(abs(lat), latdir, abs(lon), londir)\n\n # main function code\n if do_print:\n start_page_division(outfile, \"base_page\")\n else:\n common_header_part1(outfile, loc.trimmed_name, indexpath=\"../\")\n if not loc.unknown:\n start_google_map_header(outfile)\n write_google_map_point_header(outfile, \"location_\" + place_to_filename(loc.name))\n end_google_map_header(outfile)\n common_header_part2(outfile, indexpath=\"../\", include_map=True)\n\n outfile.write(\" <header id=\\\"\" + place_to_filename(loc.name) + \".html\\\">\\n\")\n outfile.write(\" <h1 class=\\\"nobookmark\\\">\" + loc.trimmed_name + \"</h1>\\n\")\n if not do_print:\n outfile.write(\" <nav>\\n\")\n outfile.write(\" <ul>\\n\")\n outfile.write(\" <li><a href=\\\"index.html\\\">\" + fetch_fa_glyph(\"index\") + \"Location Index</a></li>\\n\")\n outfile.write(\" </ul>\\n\")\n outfile.write(\" </nav>\\n\")\n outfile.write(\" </header>\\n\")\n outfile.write(\" <dl>\\n\")\n\n if loc.n_alternates() > 0:\n outfile.write(\" <dt>Also Known As</dt>\\n\")\n outfile.write(\" <dd>\" + \", \".join(loc.alternates) + \"</dd>\\n\")\n if loc.n_parents() > 0:\n outfile.write(\" <dt>Included Within</dt>\\n\")\n if loc.parent is not None:\n p = point_locations[loc.parent]\n dstr = create_location_link(p, p.trimmed_name, do_print)\n else:\n dstr = None\n if loc.n_secondary_parents() > 0:\n if dstr is None:\n dlist = []\n else:\n dlist = [dstr]\n for a in loc.secondary_parents:\n p = point_locations[a]\n dlist.append(create_location_link(p, p.trimmed_name, do_print))\n dstr = \", \".join(dlist)\n outfile.write(\" <dd>\" + dstr + \"</dd>\\n\")\n if loc.unknown:\n outfile.write(\" <dt>Location Could not be Identified</dt>\\n\")\n if loc.notes is not None:\n outfile.write(\" <dd>\" + loc.notes + \"</dd>\\n\")\n else:\n if loc.notes is not None:\n outfile.write(\" <dt>Note</dt>\\n\")\n outfile.write(\" <dd>\" + loc.notes + \"</dd>\\n\")\n outfile.write(\" <dt>Approximate Coordinates</dt>\\n\")\n outfile.write(\" <dd>\" + format_latlon(loc.latitude, loc.longitude) + \"</dd>\\n\")\n outfile.write(\" <div class=\\\"map_section\\\">\\n\")\n if do_print:\n outfile.write(\" <figure>\\n\")\n outfile.write(\" <img src=\\\"\" + TMP_MAP_PATH +\n pointmap_name(\"location_\" + place_to_filename(loc.name)) + \".png\\\" alt=\\\"\" +\n loc.trimmed_name + \"\\\" title=\\\"Map of \" + loc.trimmed_name + \"\\\" />\\n\")\n outfile.write(\" </figure>\\n\")\n else:\n outfile.write(\" <div id=\\\"point_map_canvas\\\" class=\\\"sp_map\\\"></div>\\n\")\n\n outfile.write(\" <div class=\\\"map_download\\\">\\n\")\n outfile.write(\" The red marker indicates the coordinates used to represent this location, \"\n \"yellow markers all other locations contained within this location. Purple markers indicate \"\n \"fossil-only locations or sub-locations.\\n\")\n outfile.write(\" </div>\\n\")\n\n outfile.write(\" </div>\\n\")\n outfile.write(\" </dl>\\n\")\n all_species = set()\n all_species |= location_species[loc.name]\n all_bi_names = set()\n all_bi_names |= location_bi_names[loc.name]\n all_sp_names = set()\n all_sp_names |= location_sp_names[loc.name]\n all_refs = set()\n all_refs |= location_direct_refs[loc.name]\n all_refs |= location_cited_refs[loc.name]\n if loc.n_direct_children() > 0:\n outfile.write(\" <section class=\\\"spsection\\\">\\n\")\n outfile.write(\" <h3 class=\\\"nobookmark\\\">Includes Subareas</h3>\\n\")\n outfile.write(\" <ul class=\\\"locpagelist\\\">\\n\")\n for c in loc.direct_children():\n outfile.write(\" <li>\" + create_location_link(c, c.trimmed_name, do_print) + \"</li>\\n\")\n all_species |= fetch_child_data(c, location_species)\n all_bi_names |= fetch_child_data(c, location_bi_names)\n all_sp_names |= fetch_child_data(c, location_sp_names)\n all_refs |= fetch_child_ref_data(c, location_direct_refs)\n all_refs |= fetch_child_ref_data(c, location_cited_refs)\n outfile.write(\" </ul>\\n\")\n outfile.write(\" </section>\\n\")\n\n # add species\n range_species = set(find_species_by_name(s) for s in locations_range_species[loc])\n range_species -= all_species\n all_species |= range_species\n\n is_error = True\n print_star = False\n print_double = False\n outfile.write(\" <section class=\\\"spsection\\\">\\n\")\n outfile.write(\" <h3 class=\\\"nobookmark\\\">Currently Recognized Species</h3>\\n\")\n if len(all_species) > 0:\n is_error = False\n # outfile.write(\" <section class=\\\"spsection\\\">\\n\")\n # outfile.write(\" <h3 class=\\\"nobookmark\\\">Currently Recognized Species</h3>\\n\")\n outfile.write(\" <ul class=\\\"locpagelist\\\">\\n\")\n for s in sorted(list(all_species)):\n if s in location_species[loc.name]:\n suffix = \"\"\n elif s in range_species:\n suffix = DOUBLEDAGGER\n print_double = True\n else:\n suffix = STAR\n print_star = True\n outfile.write(\" <li>\" +\n create_species_link(s.genus, s.species, do_print, status=s.status, path=\"../\") +\n suffix + \"</li>\\n\")\n outfile.write(\" </ul>\\n\")\n else:\n outfile.write(\" <p>None</p>\\n\")\n outfile.write(\" </section>\\n\")\n\n if len(all_bi_names) > 0:\n is_error = False\n outfile.write(\" <section class=\\\"spsection\\\">\\n\")\n outfile.write(\" <h3 class=\\\"nobookmark\\\">Names Which Have Been Used for This Area</h3>\\n\")\n outfile.write(\" <ul class=\\\"locpagelist\\\">\\n\")\n for s in sorted(list(all_bi_names)):\n if s in location_bi_names[loc.name]:\n suffix = \"\"\n else:\n suffix = STAR\n print_star = True\n outfile.write(\" <li><a href=\\\"\" + rel_link_prefix(do_print, \"../names/\") + name_to_filename(s) +\n \".html\\\">\" + format_name_string(s) + \"</a>\" + suffix + \"</li>\\n\")\n outfile.write(\" </ul>\\n\")\n outfile.write(\" </section>\\n\")\n\n if len(all_sp_names) > 0:\n is_error = False\n outfile.write(\" <section class=\\\"spsection\\\">\\n\")\n outfile.write(\" <h3 class=\\\"nobookmark\\\">Specific Names Which Have Been Used for This Area</h3>\\n\")\n outfile.write(\" <ul class=\\\"locpagelist\\\">\\n\")\n for s in sorted(list(all_sp_names)):\n if s in location_sp_names[loc.name]:\n suffix = \"\"\n else:\n suffix = STAR\n print_star = True\n outfile.write(\" <li><a href=\\\"\" + rel_link_prefix(do_print, \"../names/\") + \"sn_\" + s.name +\n \".html\\\">\" + format_name_string(s.name) + \"</a>\" + suffix + \"</li>\\n\")\n outfile.write(\" </ul>\\n\")\n outfile.write(\" </section>\\n\")\n\n # the following is to identify locations which may no longer used in the DB and can be removed\n # if is_error:\n # report_error(\"Phantom Location: \" + loc.name)\n\n write_annotated_reference_list(outfile, do_print, references, all_refs, location_direct_refs[loc.name],\n location_cited_refs[loc.name], \"../\")\n\n if len(location_direct_refs[loc.name]) != len(location_cited_refs[loc.name]):\n key_str = \"Entries marked with \" + DAGGER + \" represent indirect references to location through citation. \"\n else:\n key_str = \"\"\n if print_star:\n key_str += \"Entries marked with \" + STAR + \" are inferred from subareas. \"\n if print_double:\n key_str += \"Entries marked with \" + DOUBLEDAGGER + \" represent potential inhabitants inferred from \" \\\n \"species ranges.\"\n if key_str != \"\":\n outfile.write(\" <p>\" + key_str.strip() + \"</p>\\n\")\n\n if do_print:\n end_page_division(outfile)\n else:\n common_html_footer(outfile)\n\n # output place specific taxonomic key\n if (location_keys is not None) and (len(all_species) > 0):\n if do_print:\n write_taxonomic_key(outfile, do_print, location_keys[frozenset(all_species)], loc)\n else:\n with open(WEBOUT_PATH + \"locations/keys/\" + place_to_filename(loc.name) + \"_taxkey.html\", \"w\",\n encoding=\"utf-8\") as suboutfile:\n write_taxonomic_key(suboutfile, do_print, location_keys[frozenset(all_species)], loc)\n\n # write out children pages (primary children only)\n if loc.n_children() > 0:\n for c in loc.children:\n if do_print:\n write_location_page(outfile, do_print, c, point_locations, location_species, location_bi_names,\n location_sp_names, location_direct_refs, location_cited_refs, references,\n locations_range_species, location_keys)\n else:\n with open(WEBOUT_PATH + \"locations/\" + place_to_filename(c.name) + \".html\", \"w\",\n encoding=\"utf-8\") as suboutfile:\n write_location_page(suboutfile, do_print, c, point_locations, location_species, location_bi_names,\n location_sp_names, location_direct_refs, location_cited_refs, references,\n locations_range_species, location_keys)","def create_url(keyword, hits_limit, start_record, api_key):\n keyword = requests.utils.quote(keyword)\n url_base = (\"http://kulturarvsdata.se/ksamsok/api?x-api={api_key}\"\n \"&method=search&hitsPerPage={hits_limit}\"\n \"&startRecord={start_record}\"\n \"&query=serviceOrganization=RA%C3%84%20\"\n \"and%20serviceName=KMB%20\"\n \"and%20itemType=foto%20and%20mediaLicense=*%20\"\n \"and%20text={keyword}\")\n return url_base.format(api_key=api_key,\n hits_limit=hits_limit,\n start_record=start_record,\n keyword=keyword)","def build_map(chunk_start, result, total_chunks, start_id, end_id):\n size = len(chunk_start)\n for i in prange(size):\n beg = chunk_start[i]\n end = chunk_start[i + 1] if i < size - 1 else total_chunks\n if start_id < end and beg < end_id: # [beg, end) intersect [start_id, end_id)\n result[max(beg - start_id, 0) : (end - start_id), 0] = beg\n result[max(beg - start_id, 0) : (end - start_id), 1] = end","def format_coordinates(max_lat, max_lng, min_lat, min_lng, centre_lat, centre_lng):\n centre_coordinate = str(centre_lat) + ', ' + str(centre_lng)\n bottom_left_coordinate = str(min_lat) + ', ' + str(min_lng)\n top_right_coordinate = str(max_lat) + ', ' + str(max_lng)\n\n return centre_coordinate + '&bounds=' + bottom_left_coordinate + '|' + top_right_coordinate","def generate_map(self):\n\n # Create main streets first\n self.create_main_streets()\n\n # Then create the commercial buildings in the center of town\n self.create_commercial_center()\n\n # Then create the neighborhoods that populate the rest of the city\n while(self.create_neighborhood()):\n pass\n\n # Clean up any invalid buildings that were created\n self.delete_inaccessible_buildings()","def build_request_url(symbol, start_date, end_date):\n pass","def maps():\n\n if request.env.request_method == \"GET\":\n # This is a request to read the config of a saved map\n\n # Which map are we updating?\n id = request.args(0)\n if not id:\n raise HTTP(501)\n\n # Read the WMC record\n record = db(db.gis_wmc.id == id).select(limitby=(0, 1)).first()\n # & linked records\n #projection = db(db.gis_projection.id == record.projection).select(limitby=(0, 1)).first()\n\n # Put details into the correct structure\n output = dict()\n output[\"map\"] = dict()\n map = output[\"map\"]\n map[\"center\"] = [record.lat, record.lon]\n map[\"zoom\"] = record.zoom\n # @ToDo: Read Projection (we generally use 900913 & no way to edit this yet)\n map[\"projection\"] = \"EPSG:900913\"\n map[\"units\"] = \"m\"\n map[\"maxResolution\"] = 156543.0339\n map[\"maxExtent\"] = [ -20037508.34, -20037508.34, 20037508.34, 20037508.34 ]\n # @ToDo: Read Layers\n map[\"layers\"] = []\n #map[\"layers\"].append(dict(source=\"google\", title=\"Google Terrain\", name=\"TERRAIN\", group=\"background\"))\n #map[\"layers\"].append(dict(source=\"ol\", group=\"background\", fixed=True, type=\"OpenLayers.Layer\", args=[ \"None\", {\"visibility\":False} ]))\n for _layer in record.layer_id:\n layer = db(db.gis_wmc_layer.id == _layer).select(limitby=(0, 1)).first()\n if layer.type_ == \"OpenLayers.Layer\":\n # Add args\n map[\"layers\"].append(dict(source=layer.source, title=layer.title, name=layer.name, group=layer.group_, type=layer.type_, format=layer.img_format, visibility=layer.visibility, transparent=layer.transparent, opacity=layer.opacity, fixed=layer.fixed, args=[ \"None\", {\"visibility\":False} ]))\n else:\n map[\"layers\"].append(dict(source=layer.source, title=layer.title, name=layer.name, group=layer.group_, type=layer.type_, format=layer.img_format, visibility=layer.visibility, transparent=layer.transparent, opacity=layer.opacity, fixed=layer.fixed))\n\n # @ToDo: Read Metadata (no way of editing this yet)\n\n # Encode as JSON\n output = json.dumps(output)\n\n # Output to browser\n response.headers[\"Content-Type\"] = \"application/json\"\n return output\n\n elif request.env.request_method == \"POST\":\n # This is a request to save/publish a new map\n\n # Get the data from the POST\n source = request.body.read()\n if isinstance(source, basestring):\n from StringIO import StringIO\n source = StringIO(source)\n\n # Decode JSON\n source = json.load(source)\n # @ToDo: Projection (we generally use 900913 & no way to edit this yet)\n lat = source[\"map\"][\"center\"][0]\n lon = source[\"map\"][\"center\"][1]\n zoom = source[\"map\"][\"zoom\"]\n # Layers\n layers = []\n for layer in source[\"map\"][\"layers\"]:\n try:\n opacity = layer[\"opacity\"]\n except:\n opacity = None\n try:\n name = layer[\"name\"]\n except:\n name = None\n _layer = db((db.gis_wmc_layer.source == layer[\"source\"]) &\n (db.gis_wmc_layer.name == name) &\n (db.gis_wmc_layer.visibility == layer[\"visibility\"]) &\n (db.gis_wmc_layer.opacity == opacity)\n ).select(db.gis_wmc_layer.id,\n limitby=(0, 1)).first()\n if _layer:\n # This is an existing layer\n layers.append(_layer.id)\n else:\n # This is a new layer\n try:\n type_ = layer[\"type\"]\n except:\n type_ = None\n try:\n group_ = layer[\"group\"]\n except:\n group_ = None\n try:\n fixed = layer[\"fixed\"]\n except:\n fixed = None\n try:\n format = layer[\"format\"]\n except:\n format = None\n try:\n transparent = layer[\"transparent\"]\n except:\n transparent = None\n # Add a new record to the gis_wmc_layer table\n _layer = db.gis_wmc_layer.insert(source=layer[\"source\"], name=name, visibility=layer[\"visibility\"], opacity=opacity, type_=type_, title=layer[\"title\"], group_=group_, fixed=fixed, transparent=transparent, img_format=format)\n layers.append(_layer)\n\n # @ToDo: Metadata (no way of editing this yet)\n\n # Save a record in the WMC table\n id = db.gis_wmc.insert(lat=lat, lon=lon, zoom=zoom, layer_id=layers)\n\n # Return the ID of the saved record for the Bookmark\n output = json.dumps(dict(id=id))\n return output\n\n elif request.env.request_method == \"PUT\":\n # This is a request to save/publish an existing map\n\n # Which map are we updating?\n id = request.args(0)\n if not id:\n raise HTTP(501)\n\n # Get the data from the PUT\n source = request.body.read()\n if isinstance(source, basestring):\n from StringIO import StringIO\n source = StringIO(source)\n\n # Decode JSON\n source = json.load(source)\n # @ToDo: Projection (unlikely to change)\n lat = source[\"map\"][\"center\"][0]\n lon = source[\"map\"][\"center\"][1]\n zoom = source[\"map\"][\"zoom\"]\n # Layers\n layers = []\n for layer in source[\"map\"][\"layers\"]:\n try:\n opacity = layer[\"opacity\"]\n except:\n opacity = None\n try:\n name = layer[\"name\"]\n except:\n name = None\n _layer = db((db.gis_wmc_layer.source == layer[\"source\"]) &\n (db.gis_wmc_layer.name == name) &\n (db.gis_wmc_layer.visibility == layer[\"visibility\"]) &\n (db.gis_wmc_layer.opacity == opacity)\n ).select(db.gis_wmc_layer.id,\n limitby=(0, 1)).first()\n if _layer:\n # This is an existing layer\n layers.append(_layer.id)\n else:\n # This is a new layer\n try:\n type_ = layer[\"type\"]\n except:\n type_ = None\n try:\n group_ = layer[\"group\"]\n except:\n group_ = None\n try:\n fixed = layer[\"fixed\"]\n except:\n fixed = None\n try:\n format = layer[\"format\"]\n except:\n format = None\n try:\n transparent = layer[\"transparent\"]\n except:\n transparent = None\n # Add a new record to the gis_wmc_layer table\n _layer = db.gis_wmc_layer.insert(source=layer[\"source\"], name=name, visibility=layer[\"visibility\"], opacity=opacity, type_=type_, title=layer[\"title\"], group_=group_, fixed=fixed, transparent=transparent, img_format=format)\n layers.append(_layer)\n\n # @ToDo: Metadata (no way of editing this yet)\n\n # Update the record in the WMC table\n db(db.gis_wmc.id == id).update(lat=lat, lon=lon, zoom=zoom, layer_id=layers)\n\n # Return the ID of the saved record for the Bookmark\n output = json.dumps(dict(id=id))\n return output\n\n # Abort - we shouldn't get here\n raise HTTP(501)","def home():\n return (\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"/api/v1.0/<start>/<end>\"\n \n )","def _map_base_url(base):\n # This uses eventual consistency and cannot be made strongly consistent.\n for rule in models_chromium.UrlMap.query().order(\n models_chromium.UrlMap.base_url_template):\n base_template = r'^%s$' % rule.base_url_template\n match = re.match(base_template, base)\n if not match:\n continue\n try:\n src_url = re.sub(base_template,\n rule.source_code_url_template,\n base)\n except re.error, err:\n logging.error('err: %s base: \"%s\" rule: \"%s\" => \"%s\"',\n err, base, rule.base_url_template,\n rule.source_code_url_template)\n return None\n return src_url\n return None","def render_map(map,\nlat=None,\nlon=None,\ntitle=None,\nsave=True,\nshow=True,\nschedule=None,\nschedule_bbox=(-0.03,0,1,0.91),\nimg_filename=None,\nimg_dir=\"\",\nimg_size=[20,15],\nimg_dpi=300,\nimg_filetype=\"png\",\nbrdr_nation=True,\nbrdr_nation_rgba=[0,0,0,1],\nbrdr_state=True,\nbrdr_state_rgba=[0,0,0,0.75],\ncmap=\"gist_ncar\",\ncmap_limits=None,\ncbar=True,\ncbar_limits=None,\ncbar_label=None,\ncountry_focus=\"CHE\",\ngridlines=True,\ngridlines_dms=False,\nmch_logo=True) :\n\n # TODO: Add custom sizing and resolution specifications\n fig = plt.figure(figsize=(img_size[0]/2.54,img_size[1]/2.54))\n\n # TODO: Accept custom projections\n # proj = ccrs.Mercator()\n proj = ccrs.Orthographic(central_longitude=(lon[0]+lon[-1])/2, central_latitude=(lat[0]+lat[-1])/2)\n\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\n ax = fig.add_subplot(1,1,1,projection = proj)\n\n # TODO: Increase flexibility of borders consideration\n if brdr_state :\n state_brdrs = cfeat.NaturalEarthFeature(\n category='cultural',\n name='admin_1_states_provinces_lines',\n scale='10m',\n facecolor='none')\n ax.add_feature(state_brdrs,linestyle=\"--\",edgecolor=tuple(brdr_state_rgba),linewidth=0.5)\n if brdr_nation :\n ax.add_feature(cfeat.BORDERS,edgecolor=tuple(brdr_nation_rgba))\n\n if country_focus is not None :\n shpfilename = shapereader.natural_earth(resolution='10m',\n category='cultural',name='admin_0_countries')\n reader = shapereader.Reader(shpfilename)\n countries = reader.records() \n # this is a very janky search for Switzerland, but it's ultimately simpler than\n # making geopandas a requirement for the library\n for country in countries :\n if country.attributes['ADM0_A3'] == country_focus :\n break\n assert country.attributes['ADM0_A3'] == country_focus, \"country_focus input not recognised\"\n poly = country.geometry\n\n msk_proj = proj.project_geometry (poly, ccrs.Geodetic()) # project geometry to the projection used by stamen\n\n # plot the mask using semi-transparency (alpha=0.65) on the masked-out portion\n ax.add_geometries( msk_proj, proj, facecolor='white', edgecolor='none', alpha=0.8)\n\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\n extents=[lon[0],lon[-1],lat[0],lat[-1]]\n ax.set_extent(extents,crs=ccrs.Geodetic())\n\n # this code correctly translate the lat/lon limits into the projected coordinates\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\n extents_proj = extents_proj[:,:2].flatten(order='F')\n\n if gridlines :\n ax.gridlines(draw_labels=True, dms=gridlines_dms, x_inline=False, y_inline=False,linewidth=0.25,\n ylocs=[46,46.5,47,47.5])\n\n # TODO: Custom colormaps, interpolation, cropping\n\n # Upscale matrix for better reprojection\n # f = interp2d(lon, lat, map, kind='linear')\n # latnew = np.linspace(lat[0], lat[-1], (len(lat)-1)*3+1)\n # lonnew = np.linspace(lon[0], lon[-1], (len(lon)-1)*3+1)\n # mapnew = f(lonnew, latnew)\n\n # Upscale matrix for better reprojection\n mapnew = zoom(map,3)\n\n # show map with given cmap and set cmap limits\n im = ax.imshow(mapnew,extent=extents,transform=ccrs.PlateCarree(),\n origin='lower',cmap=cmap)\n if cmap_limits is not None :\n im.set_clim(cmap_limits[0],cmap_limits[1])\n\n # colorbar\n # TODO: Add support for horizontal vertical option\n if cbar :\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\n cb.ax.set_xlabel(cbar_label)\n\n # show schedule diagram\n if schedule is not None :\n ax2 = inset_axes(ax, width=\"25%\", height=\"25%\", loc=2,\n axes_class = get_projection_class('polar'),\n bbox_to_anchor=tuple(schedule_bbox),\n bbox_transform=ax.transAxes)\n schedule_clock(ax2,schedule,title=\"Exposure schedule\")\n\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\n if title is not None :\n ax.set_title(title)\n\n if mch_logo :\n ex = ax.get_extent()\n mch_logo_img = plt.imread('python_tamer/mch_logo.png')\n mch_logo_width = 0.15\n mch_logo_pad = 0\n # some maths to work out position, note image aspect ratio 5:1\n mch_extents = [ex[1]-(ex[1]-ex[0])*mch_logo_width-(ex[1]-ex[0])*mch_logo_pad,\n ex[1]-(ex[1]-ex[0])*mch_logo_pad,\n ex[2]+(ex[3]-ex[2])*mch_logo_pad,\n ex[2]+0.2*(ex[1]-ex[0])*mch_logo_width+(ex[3]-ex[2])*mch_logo_pad]\n # zorder puts image on top (behind mask otherwise for some reason)\n ax.imshow(mch_logo_img,extent=mch_extents,zorder=12)\n\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\n if save :\n # Generate timestamp filename if relying on default\n if img_filename is None :\n if title is not None :\n img_filename = format_filename(title)\n else :\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\n elif img_filename == \"timestamp\" :\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\n\n plt.savefig(img_dir+img_filename+\".\"+img_filetype,\n bbox_inches=\"tight\",dpi=img_dpi)\n\n if show :\n plt.show()","def _newurl(counter):\n return \"%s/sitemap-%s.xml.gz\" % (settings.SITEMAPS_BASE_URL, counter)","def home():\n m = Map() # Create map html\n return render_template('index.html') # pulls map html using jinja2","def _createmap(self, family_x, color, place_list, reference):\n dbstate = self.dbstate\n self.cal = config.get('preferences.calendar-format-report')\n self.place_list = place_list\n self.place_without_coordinates = []\n self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0\n #self.minyear = 9999\n #self.maxyear = 0\n latitude = \"\"\n longitude = \"\"\n self.place_list = []\n self.place_without_coordinates = []\n self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0\n #family = self.dbstate.db.get_family_from_handle(family_x)\n family = family_x\n if family is None:\n person = self.dbstate.db.get_family_from_handle(self.uistate.get_active('Person'))\n if not person:\n return\n family_list = person.get_family_handle_list()\n for family_hdl in family_list:\n family = self.dbstate.db.get_family_from_handle(family_hdl)\n if family is not None:\n self._createmap_for_one_family(family, color, place_list, reference)\n else:\n self._createmap_for_one_family(family, color, place_list, reference)\n #self._create_markers()","def makeLandingUrl(self, artMeta):\n self._readIssns()\n issn = getIssn(artMeta)\n if issn in self.highwireIssns:\n baseUrl = self.highwireIssns[issn]\n delayTime = self._highwireDelay(baseUrl)\n vol = artMeta.get('vol', '')\n issue = artMeta.get('issue', '')\n page = artMeta.get('page', '')\n if (vol, issue, page) != ('', '', '') and ' ' not in vol + issue + page:\n url = '%s/content/%s/%s/%s.long' % (baseUrl,\n vol,\n issue,\n page)\n page = httpGetDelay(url, delayTime)\n if page != None:\n return url\n if 'pmid' in artMeta:\n url = '%s/cgi/pmidlookup?view=long&pmid=%s' % (baseUrl, artMeta['pmid'])\n page = httpGetDelay(url, delayTime)\n if page != None:\n return url\n return","def fill_template(map_filepath, resolution, origin): # NOTE: Copied from generate_map_yaml.py\n template = \"\"\"image: MAP_FILEPATH\nresolution: RESOLUTION\norigin: [ORIGIN_X, ORIGIN_Y, YAW]\nnegate: 0\noccupied_thresh: 0.65\nfree_thresh: 0.196\n\"\"\"\n template = template.replace('MAP_FILEPATH', map_filepath)\n template = template.replace('RESOLUTION', str(resolution))\n template = template.replace('ORIGIN_X', str(origin[0]))\n template = template.replace('ORIGIN_Y', str(origin[1]))\n template = template.replace('YAW', str(origin[2]))\n return template","def _makeimap(self):\n self.map_['source'] = 'GOES'\n self.map_['provider'] = 'NOAA'\n self.map_['instrument'] = 'SUVI'\n self.map_['physobs'] = 'flux'","def build_map(locations: list, user_location: tuple, year: int):\n main_map = folium.Map(location=[user_location[0],\n user_location[1]], zoom_start=4)\n user_loc = folium.FeatureGroup(name=\"Your location\")\n all_markers = folium.FeatureGroup(name=\"All markers location\", show=False)\n ten_markers = folium.FeatureGroup(name=\"10 nearest markers\")\n user_loc.add_child(folium.Marker(\n location=[user_location[0], user_location[1]], popup='Your location',\n icon=folium.Icon(color='red')))\n for i in locations[10:]:\n all_markers.add_child(folium.Marker(\n location=[i[1][0], i[1][1]], popup=i[0], icon=folium.Icon(color='green')))\n for i in locations[:10]:\n ten_markers.add_child(folium.Marker(\n location=[i[1][0], i[1][1]], popup=i[0], icon=folium.Icon()))\n main_map.add_child(user_loc)\n main_map.add_child(ten_markers)\n main_map.add_child(all_markers)\n main_map.add_child(folium.LayerControl())\n map_name = str(year) + '_movies_map.html'\n main_map.save(map_name)","def formatUrl(url, searchTerms, startTime, endTime, bbox, limit=None, start=None):\n \n #interpolate searchTerms if not empty; otherwise remove parameter\n if searchTerms == '':\n url = re.sub(r'(&?\\w+?)={(?:os:)?searchTerms\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={(?:os:)?searchTerms\\??}', r'\\1=%s' %\n urllib.quote_plus(searchTerms), url)\n \n #interpolate startTime if not empty; otherwise remove parameter\n if startTime == '':\n url = re.sub(r'(&?\\w+?)={time:start\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={time:start\\??}', r'\\1=%s' %\n urllib.quote_plus(startTime), url)\n \n #interpolate endTime if not empty; otherwise remove parameter\n if endTime == '':\n url = re.sub(r'(&?\\w+?)={time:end\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={time:end\\??}', r'\\1=%s' %\n urllib.quote_plus(endTime), url)\n \n #interpolate bbox if not empty; otherwise remove parameter\n if bbox == '':\n url = re.sub(r'(&?\\w+?)={geo:box\\??}', '', url)\n url = re.sub(r'(&?\\w+?)={georss:box\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={geo:box\\??}', r'\\1=%s' %\n urllib.quote_plus(bbox), url)\n url = re.sub(r'(&?\\w+?)={georss:box\\??}', r'\\1=%s' %\n urllib.quote_plus(bbox), url)\n \n #interpolate count if not empty; otherwise remove parameter\n if limit is None:\n url = re.sub(r'(&?\\w+?)={(?:os:)?count\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={(?:os:)?count\\??}', r'\\1=%s' %\n urllib.quote_plus(str(limit)), url)\n \n #interpolate startIndex if not empty; otherwise remove parameter\n if start is None:\n url = re.sub(r'(&?\\w+?)={(?:os:)?startIndex\\??}', '', url)\n else:\n url = re.sub(r'(&?\\w+?)={(?:os:)?startIndex\\??}', r'\\1=%s' %\n urllib.quote_plus(str(start)), url)\n \n #interpolate startPage if not empty; otherwise remove parameter\n if limit is None:\n url = re.sub(r'(&?\\w+?)={(?:os:)?startPage\\??}', '', url)\n else:\n if start is not None: startPage = start/limit+1\n else: startPage = 1\n url = re.sub(r'(&?\\w+?)={(?:os:)?startPage\\??}',\n urllib.quote_plus(str(startPage)), url) \n \n #clear out other template items\n url = re.sub(r'(&?\\w+?)={\\w+?:\\w+\\??}', '', url)\n \n #replace ' ' with '+'\n url = url.replace(' ', '+')\n \n return url","def html_page():\n return render_template('Map_twitter.html')","def build_url (label, base, end):\n clean_label = re.sub (r'([ ]+_)|(_[ ]+)|([ ]+)', '_', label)\n return '%s%s%s' % (base, clean_label, end)","def _get_basemap(self, projection='lambert', geopolygons=None, resolution='i', bound=True, hillshade=False):\n\t\t# fig=plt.figure(num=None, figsize=(12, 12), dpi=80, facecolor='w', edgecolor='k')\n\t\tminlat = self.attrs['minlat']\n\t\tmaxlat = self.attrs['maxlat']\n\t\tminlon = self.attrs['minlon']\n\t\tmaxlon = self.attrs['maxlon']\n\t\tlat_centre = (maxlat+minlat)/2.0\n\t\tlon_centre = (maxlon+minlon)/2.0\n\t\tif projection=='merc':\n\t\t\tm=Basemap(projection='merc', llcrnrlat=minlat-5., urcrnrlat=maxlat+5., llcrnrlon=minlon-5.,\n\t\t\t\t\t urcrnrlon=maxlon+5., lat_ts=20, resolution=resolution)\n\t\t\t# m.drawparallels(np.arange(minlat,maxlat,dlat), labels=[1,0,0,1])\n\t\t\t# m.drawmeridians(np.arange(minlon,maxlon,dlon), labels=[1,0,0,1])\n\t\t\tm.drawparallels(np.arange(-80.0,80.0,2.0), dashes=[2,2], labels=[1,0,0,0], fontsize=12)\n\t\t\tm.drawmeridians(np.arange(-170.0,170.0,2.0), dashes=[2,2], labels=[0,0,1,0], fontsize=12)\n\t\t\tm.drawstates(color='g', linewidth=2.)\n\t\telif projection=='global':\n\t\t\tm=Basemap(projection='ortho',lon_0=lon_centre, lat_0=lat_centre, resolution=resolution)\n\t\t\t# m.drawparallels(np.arange(-80.0,80.0,10.0), labels=[1,0,0,1])\n\t\t\t# m.drawmeridians(np.arange(-170.0,170.0,10.0), labels=[1,0,0,1])\n\t\telif projection=='regional_ortho':\n\t\t\tm1 = Basemap(projection='ortho', lon_0=minlon, lat_0=minlat, resolution='l')\n\t\t\tm = Basemap(projection='ortho', lon_0=minlon, lat_0=minlat, resolution=resolution,\\\n\t\t\t\tllcrnrx=0., llcrnry=0., urcrnrx=m1.urcrnrx/mapfactor, urcrnry=m1.urcrnry/3.5)\n\t\t\tm.drawparallels(np.arange(-80.0,80.0,10.0), labels=[1,0,0,0], linewidth=2, fontsize=20)\n\t\t\t# m.drawparallels(np.arange(-90.0,90.0,30.0),labels=[1,0,0,0], dashes=[10, 5], linewidth=2, fontsize=20)\n\t\t\t# m.drawmeridians(np.arange(10,180.0,30.0), dashes=[10, 5], linewidth=2)\n\t\t\tm.drawmeridians(np.arange(-170.0,170.0,10.0), linewidth=2)\n\t\telif projection=='lambert':\n\t\t\tdistEW, az, baz=obspy.geodetics.gps2dist_azimuth(minlat, minlon, minlat, maxlon) # distance is in m\n\t\t\tdistNS, az, baz=obspy.geodetics.gps2dist_azimuth(minlat, minlon, maxlat+2., minlon) # distance is in m\n\t\t\tm = Basemap(width=distEW, height=distNS, rsphere=(6378137.00,6356752.3142), resolution='l', projection='lcc',\\\n\t\t\t\tlat_1=minlat, lat_2=maxlat, lon_0=lon_centre, lat_0=lat_centre)\n\t\t\tm.drawparallels(np.arange(-80.0,80.0,2.0), linewidth=1, dashes=[2,2], labels=[1,0,0,0], fontsize=12)\n\t\t\tm.drawmeridians(np.arange(-170.0,170.0,2.0), linewidth=1, dashes=[2,2], labels=[0,0,1,0], fontsize=12)\n\t\t\t# m.drawparallels(np.arange(-80.0,80.0,10.0), linewidth=0.5, dashes=[2,2], labels=[1,0,0,0], fontsize=5)\n\t\t\t# m.drawmeridians(np.arange(-170.0,170.0,10.0), linewidth=0.5, dashes=[2,2], labels=[0,0,0,1], fontsize=5)\n\t\tm.drawcoastlines(linewidth=1.0)\n\t\tm.drawcountries(linewidth=1.0)\n\t\tm.drawstates(linewidth=1.0)\n\t\t# m.drawmapboundary(fill_color=[1.0,1.0,1.0])\n\t\t# m.fillcontinents(lake_color='#99ffff',zorder=0.2)\n\t\t# m.drawlsmask(land_color='0.8', ocean_color='#99ffff')\n\t\tm.drawmapboundary(fill_color=\"white\")\n\t\tif bound:\n\t\t\ttry:\n\t\t\t\t# m.readshapefile('/projects/howa1663/Code/ToolKit/Models/Plates/PB2002_boundaries', name='PB2002_boundaries', drawbounds=True, linewidth=1, color='orange') # draw plate boundary on basemap\n\t\t\t\t#m.readshapefile('/work3/wang/code_bkup/AgeJdF/Plates/PB2002_boundaries', name='PB2002_boundaries', drawbounds=True, \\\n\t\t\t\t#\t\tlinewidth=1, color='orange')\n\t\t\t\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/ridge',name='ridge',drawbounds=True, linewidth=1, color='orange')\n\t\t\t\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/trench',name='trench',drawbounds=True, linewidth=1, color='orange')\n\t\t\t\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/transform',name='transform',drawbounds=True, linewidth=1, color='orange')\n\t\t\texcept IOError:\n\t\t\t\tprint(\"Couldn't read shape file! Continue without drawing plateboundaries\")\n\t\ttry:\n\t\t\tgeopolygons.PlotPolygon(inbasemap=m)\n\t\texcept:\n\t\t\tpass\n\t\tif hillshade:\n\t\t\tfrom netCDF4 import Dataset\n\t\t\tfrom matplotlib.colors import LightSource\n\t\t\tetopo1 = Dataset('/work2/wang/Code/ToolKit/ETOPO1_Ice_g_gmt4.grd','r')\n\t\t\tzz = etopo1.variables[\"z\"][:]\n\t\t\tllons = etopo1.variables[\"x\"][:]\n\t\t\twest = llons<0 # mask array with negetive longitudes\n\t\t\twest = 360.*west*np.ones(len(llons))\n\t\t\tllons = llons+west\n\t\t\tllats = etopo1.variables[\"y\"][:]\n\t\t\tetopoz = zz[(llats>(minlat-2))*(llats<(maxlat+2)), :]\n\t\t\tetopoz = etopoz[:, (llons>(minlon-2))*(llons<(maxlon+2))]\n\t\t\tllats = llats[(llats>(minlat-2))*(llats<(maxlat+2))]\n\t\t\tllons = llons[(llons>(minlon-2))*(llons<(maxlon+2))]\n\t\t\tls = LightSource(azdeg=315, altdeg=45)\n\t\t\tetopoZ = m.transform_scalar(etopoz, llons-360*(llons>180)*np.ones(len(llons)), llats, etopoz.shape[0], etopoz.shape[1])\n\t\t\tls = LightSource(azdeg=315, altdeg=45)\n\t\t\tm.imshow(ls.hillshade(etopoZ, vert_exag=1.),cmap='gray')\n\t\treturn m","def url(self):\n\t\treturn self.base_url+\"{}/{}/{}.jpg\".format(self.template,self._escape(self.top_text),self._escape(self.bottom_text))+(\"?\"+\"&\".join([\"{}={}\".format(k,quote(self.kwargs[k])) for k in self.kwargs]) if self.kwargs else \"\")","def build_url(self):\n url = requests.utils.requote_uri(\n self.torrent_page + self.string_search)\n if self.page == '1337x':\n return(url + '/1/')\n elif self.page == 'limetorrents':\n return(url + '/')\n else:\n return(url)","def __init__(self, lat, lng):\n self.summary = \"Lorem ipsum\"","def main() -> None:\n map_ssh = folium.Map(location=[45.523, -122.675], zoom_start=2)\n\n with open(\"lib/base_data.txt\") as tsv:\n for row in csv.reader(tsv, delimiter=\"\\t\"):\n name = row[0]\n try:\n x = float(row[1])\n y = float(row[2])\n folium.Marker([x, y], popup=name).add_to(map_ssh)\n except ValueError:\n pass\n\n map_ssh.save(\"map_ssh.html\")","def build_map(n=30,m=30, preset=True, filename='/home/sji367/small_grid.mat', key='new_grid'):\n if preset:\n the_map = []\n row = [0] * n\n for i in range(m):\n the_map.append(list(row))\n \n # fillout the map matrix with a '+' pattern\n for x in range(n / 8, n * 7 / 8):\n the_map[m / 2][x] = 1\n for y in range(m/8, m * 7 / 8):\n the_map[y][n / 2] = 1\n \n # randomly select start and finish locations from a list\n sf = []\n sf.append((0, 0, n - 1, m - 1))\n sf.append((0, m - 1, n - 1, 0))\n sf.append((n / 2 - 1, m / 2 - 1, n / 2 + 1, m / 2 + 1))\n sf.append((n / 2 - 1, m / 2 + 1, n / 2 + 1, m / 2 - 1))\n sf.append((n / 2 - 1, 0, n / 2 + 1, m - 1))\n sf.append((n / 2 + 1, m - 1, n / 2 - 1, 0))\n sf.append((0, m / 2 - 1, n - 1, m / 2 + 1))\n sf.append((n - 1, m / 2 + 1, 0, m / 2 - 1))\n (xStart, yStart, xFinish, yFinish) = random.choice(sf)\n else:\n grid = loadmat(filename)\n the_map = grid[key]\n xStart = 19\n yStart = 31\n xFinish = 67\n yFinish = 98\n \n return the_map, xStart, yStart, xFinish, yFinish","def _onbuttonReqMapClicked(self):\n\n day1=str(self.combo_wms_time_first_d.currentText())\n hour1=str(self.combo_wms_time_first_h.currentText())\n date_val=day1+hour1\n depth=str(self.combo_wms_layer_depth.currentText())\n variable=str(self.combo_variable_list.currentText())\n product=str(self.combo_product_list.currentText())\n dataset=str(self.combo_dataset_list.currentText())\n xmin=int(float(self.WMS_westBound.text()))\n xmax=int(float(self.WMS_eastBound.text()))\n ymin=int(float(self.WMS_southBound.text()))\n ymax=int(float(self.WMS_northBound.text()))\n dir_out=self.tmp\n rastermin=self.minscale_value.text()\n rastermax=self.maxscale_value.text()\n nb_colors=self.nbcolors_value.text()\n xpixels=float(self.Xpixels_value.text())\n xparallels=int(self.Xparallels_value.text())\n ymeridians=int(self.Ymedians_value.text())\n dpi=300\n colorbar=str(self.combo_colorbar.currentText())\n input_srs=str(self.combo_proj.currentText())\n epsg_val=input_srs.split(':')[1]\n ll_polar=False\n##\tif self.checkBox_2.isChecked() == True :\n##\t print \"Projection arctic\"\n## #m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\n## # urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \n## ##m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \n## m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \n## #Proj4js.defs[\"EPSG:3408\"] = \"+proj=laea +lat_0=90 +lon_0=0 +x_0=0 +y_0=0 +a=6371228 +b=6371228 +units=m +no_defs\";\n## #\n## ll_polar=True\n##\telif self.checkBox_3.isChecked() == True :\n##\t print \"Projection antarctic\"\n## m = Basemap(projection='spstere',boundinglat=ymax,lon_0=180,round=True,resolution='l') \n## ll_polar=True\n##\telse : \n m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\n urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \n print \"cylindric projection\"\n\n # ypixels not given, find by scaling xpixels by the map aspect ratio.\n ypixels = int(m.aspect*xpixels)\n style='boxfill/'+colorbar\n print input_srs\n print epsg_val\n p = pyproj.Proj(init=\"epsg:%s\" % epsg_val, preserve_units=True)\n xmin,ymin = p(m.llcrnrlon,m.llcrnrlat)\n xmax,ymax = p(m.urcrnrlon,m.urcrnrlat)\n if epsg_val == '4326' :\n xmin = (180./np.pi)*xmin; xmax = (180./np.pi)*xmax\n ymin = (180./np.pi)*ymin; ymax = (180./np.pi)*ymax\n print \"Cylindric projection\"\n print xmin,xmax,ymin,ymax\n print style\n img = self.wms.getmap(layers=[variable],service='wms',bbox=(xmin,ymin,xmax,ymax),\n size=(int(xpixels),ypixels),\n format='image/png',\n elevation=depth,\n srs=input_srs,\n time=date_val,\n colorscalerange=rastermin+','+rastermax,numcolorbands=nb_colors,logscale=False,\n styles=[style])\n image=imread(io.BytesIO(img.read()),format='png')\n if variable == \"sea_water_velocity\" :\n ylabel=\"magnitude\"\n else :\n ylabel=self.wms[variable].abstract\n\n long_name=self.wms[variable].title\n title=product+\" - \"+long_name+\" \"+\" - \"+date_val\n file_pal='./palettes/thredds/'+colorbar+'.pal'\n my_cmap=compute_cmap(file_pal,colorbar)\n cm.register_cmap(name=colorbar, cmap=my_cmap)\n font=10\n norm = mpl.colors.Normalize(vmin=float(rastermin), vmax=float(rastermax), clip=False) \n parallels=np.round(np.arange(ymin,ymax+xparallels/2,xparallels))\n meridians = np.round(np.arange(xmin,xmax+ymeridians/2,ymeridians))\n # Plot figure \n plt.figure(figsize=(20,12))\n if epsg_val == '4326' :\n m.drawcoastlines(color='lightgrey',linewidth=0.25)\n m.fillcontinents(color='lightgrey')\n m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\n\n elif ll_polar == True : \n #m.drawcoastlines(linewidth=0.5)\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\n m.drawmeridians(meridians[:-1],labels=[1,1,1,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\n ## Plot the image\n cs=m.imshow(image,origin='upper',alpha=1,cmap=(cm.get_cmap(colorbar,int(nb_colors))),norm=norm)\n ## Add colorbar\n cb=plt.colorbar(cs,orientation='vertical',format='%4.2f',shrink=0.7)\n cb.ax.set_ylabel(ylabel, fontsize=int(font)+4)\n cl=plt.getp(cb.ax, 'ymajorticklabels')\n plt.setp(cl, fontsize=font)\n\n plt.title(title,fontsize=font+4,y=1.05)\n plt.savefig('images/'+product+\"_\"+long_name+\"_\"+date_val+\"_basemap.png\",dpi=300,bbox_inches='tight')\n plt.show()","def sampleAndDownloadStreetImage(endPoints, sampleNum, picNum, ptrNum, targetDirectory, intersectionPointInfo):\n print \"downloading street images...\"\n sampledPoints = random.sample(endPoints, sampleNum) if sampleNum < len(endPoints) else endPoints\n sampleData = [] # store (picture number, file name, lat and lng)\n progress = Progress(10)\n headings = CONFIG[\"gmap\"][\"headings\"]\n sampleNumDelta = len(headings)\n for point in sampledPoints:\n progress.printProgress()\n result = downloadSurroundingStreetView(point, targetDirectory, picNum, ptrNum, intersectionPointInfo)\n sampleData += result\n picNum += sampleNumDelta\n ptrNum += 1\n print \"\"\n return sampleData","def build_url(vehicle, coordinates, format=\"json\", geometryformat=\"isoz\"):\n load = vehicle.load if vehicle.load > -1.0 else 0\n params = {\n \"format\": format,\n \"height\": vehicle.height,\n \"length\": vehicle.length,\n \"stops\": coordinates,\n \"load\": load,\n \"geometryformat\": geometryformat,\n \"lang\": \"nb-no\",\n }\n\n return '?'.join([ROUTE_URL_BASE, urlencode(params)])","def customization_data(client=None):\n\n # This import data contains:\n # Function inputs:\n # google_maps_destination\n # google_maps_origin\n # Message Destinations:\n # fn_google_maps_directions\n # Functions:\n # fn_google_maps_directions\n # Workflows:\n # example_google_maps_directions\n # Rules:\n # Get Directions\n\n\n yield ImportDefinition(u\"\"\"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\nLCAiZXhwb3J0X2RhdGUiOiAxNTM5ODY3NjgwMjk5fQ==\n\"\"\"\n )","def random_gps_gen_from_range(s_lat,n_lat, e_lon, w_lon):\n #print(s_lat, n_lat, e_lon, w_lon)\n latitude = random.uniform(s_lat, n_lat)\n longitude = random.uniform(e_lon, w_lon)\n return latitude, longitude","def roadSegments(locations, API_key=\"Avah46_M-gfFeQ3P1w09Qq1ElAV9ZEHFDm9b8JRCRa8qPP5uVn21hDqAPVJgV4i_\"): \n \n # Base URL\n uri = 'http://dev.virtualearth.net/' # Resource URL \n path = 'REST/v1/Routes?'\n \n \n # URL Parameters\n params = { 'wayPoint.0' : locations[0]+',Singapore',\n 'wayPoint.1' : locations[1]+',Singapore',\n 'routeAttributes':'routePath',\n 'key' : API_Key} # by default 'optimize' : 'time'} # this is by default\n \n url = uri+path\n\n results = requests.get(\n url,\n params = params\n ).json()# ['resourceSets']\n\n # Retrieving values\n statusCode = results['statusCode']\n if statusCode == 200:\n # print(statusCode)\n\n # TODO review the exceptions and modify these basic exception handlings\n try:\n travelDistance = results['resourceSets'][0]['resources'][0]['travelDistance']\n except:\n travelDistance = 0\n try:\n travelDuration = results['resourceSets'][0]['resources'][0]['travelDuration']\n except:\n travelDuration = 0\n try:\n travelDurationTraffic = results['resourceSets'][0]['resources'][0]['travelDurationTraffic']\n except:\n travelDurationTraffic = 0\n\n try:\n numberSegments = len(results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\n ['itineraryItems'])\n except:\n numberSegments = 0\n try:\n itineraryItems = results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\n ['itineraryItems']\n except:\n itineraryItems = 'No items'\n\n pathCoord = results['resourceSets'][0]['resources'][0]['routePath']['line']['coordinates']\n\n roadName = []\n travelDistances = []\n travelDurations = []\n maneuverType = []\n\n for seg in itineraryItems:\n for i in range(len(seg['details'])):\n # print(i)\n try:\n roadName.append(seg['details'][i]['names'])\n except:\n roadName.append(0)\n try:\n travelDistances.append(seg['travelDistance'])\n except:\n travelDistances.append(0)\n\n try:\n travelDurations.append(seg['travelDuration'])\n except:\n travelDurations.append(0)\n try:\n maneuverType.append(seg['details'][i]['maneuverType'])\n except:\n maneuverType.append(0)\n\n\n return statusCode,travelDistance,travelDuration,travelDurationTraffic,numberSegments,roadName, \\\n travelDistances, travelDurations, maneuverType, pathCoord\n\n else:\n print(\"Unsuccessful route calculation.\")","def map(request, template):\n lender_selected = request.GET.get('lender', '')\n metro_selected = request.GET.get('metro')\n year_selected = int(request.GET.get('year',str(Year.objects.latest().hmda_year)))\n context = {}\n lender = Institution.objects.filter(institution_id=lender_selected).select_related('agency', 'zip_code', 'lenderhierarchy').first()\n metro = Geo.objects.filter(geo_type=Geo.METRO_TYPE,geoid=metro_selected).first()\n \n if lender:\n context['lender'] = lender\n hierarchy_list = lender.get_lender_hierarchy(True, True, year_selected)\n context['institution_hierarchy'] = hierarchy_list \n if metro:\n context['metro'] = metro\n context['year'] = year_selected\n if lender and metro:\n peer_list = lender.get_peer_list(metro, True, True) \n context['institution_peers'] = peer_list\n context['download_url'] = make_download_url(lender, metro)\n context['hierarchy_download_url'] = make_download_url(hierarchy_list, metro)\n context['peer_download_url'] = make_download_url(peer_list, metro)\n context['median_loans'] = lookup_median(lender, metro) or 0\n if context['median_loans']:\n # 50000 is an arbitrary constant; should be altered if we want to\n # change how big the median circle size is\n context['scaled_median_loans'] = 50000 / context['median_loans']\n else:\n context['scaled_median_loans'] = 0\n return render(request, template, context)","def search_geoloc_range(request):\n\n distance = float(request.POST['distance'])\n\n latlng = (request.POST['latlng']).replace(\"(\",'').replace(\")\",'').split(', ')\n latitude = float(latlng[0])\n longitude = float(latlng[1])\n print distance\n print latitude\n print longitude\n\n # count range of nowa latlng\n radius_lat = (distance/(69.172)) #count latitude range\n min_lat = latitude - radius_lat\n max_lat = latitude + radius_lat\n print min_lat\n print max_lat\n\n radius_lng = (math.fabs(distance/(math.cos(longitude) * 69.172))) #count longitude range\n min_lng = longitude - radius_lng\n max_lng = longitude + radius_lng\n print min_lng\n print max_lng\n\n # if sys.version_info < (2, 7):\n # min_lat = decimal.Decimal(str(min_lat))\n # max_lat = decimal.Decimal(str(max_lat))\n # min_lng = decimal.Decimal(str(min_lng))\n # max_lng = decimal.Decimal(str(max_lng))\n\n # query db to match the range of dentist work place in db\n total = WorkPlace.objects.filter(latitude__gte=min_lat, latitude__lte=max_lat,\n longitude__gte=min_lng, longitude__lte=max_lng).count()\n\n result = []\n\n # step for how many lines separate per page. then count nowa page's start line no. and end line no.\n if 'page' in request.POST:\n page = request.POST['page']\n else:\n page = 1\n\n step = 10\n end = step * int(page)\n start = step * (int(page)-1)\n is_end = False\n\n if (end - total) < step:\n is_end = False\n WorkPlaceDict = WorkPlace.objects.filter(latitude__gte=min_lat, latitude__lte=max_lat,\n longitude__gte=min_lng, longitude__lte=max_lng).order_by('id')[start:end]\n\n for i in WorkPlaceDict:\n\n dentist_profile = i.dentistid\n did = dentist_profile.user.user.id\n\n latitude = str(i.latitude)\n longitude = str(i.longitude)\n latlng = \"(\"+latitude+\", \"+longitude+\")\"\n\n counts = _relation_counts(request,did,request.user.id)\n\n i_wrap = {\n \"clinic\": i.clinic_name,\n \"work_location\": i.location,\n \"latlng\": latlng,\n \"business_hour\": str(i.business_hour),\n \"dentistid\": did,\n \"dentistname\": _show_obj_name(did),\n \"summary\": dentist_profile.user.summary,\n \"avatar\": settings.MEDIA_URL + str(dentist_profile.user.imagesmall),\n \"patient_count\": counts[\"patient_count\"],\n \"follower_count\": counts[\"follower_count\"],\n \"status\": counts[\"status\"],\n \"is_end\": is_end\n }\n\n result.append(i_wrap)\n\n else:\n is_end = True\n i_wrap = {\n \"is_end\": is_end\n }\n\n result.append(i_wrap)\n\n template_var = {\n \"searchresult\": result\n }\n\n return JsonResponse(template_var)","def write_google_map_range_header(outfile: TextIO, map_name: str) -> None:\n outfile.write(\" var range_map = new google.maps.Map(document.getElementById(\\\"range_map_canvas\\\"),\"\n \"mapOptions);\\n\")\n outfile.write(\" var range_layer = new google.maps.KmlLayer(\\\"\" + init_data().site_url() + \"/maps/\" +\n rangemap_name(map_name) + \".kmz\\\",{suppressInfoWindows: true});\\n\")\n outfile.write(\" range_layer.setMap(range_map);\\n\")","def request_url(request):\n \n shot = request.GET['shot']\n path = request.GET['path']\n tree = request.GET['tree']\n\n xml_elmt = '{http://h1svr.anu.edu.au/}dataurlmap'\n lang_attr = {'{http://www.w3.org/XML/1998/namespace}lang': 'en'}\n url_xml = etree.Element(xml_elmt, attrib=lang_attr)\n \n shot_number = etree.SubElement(url_xml, 'shot_number', attrib={})\n shot_number.text = shot\n data_path = etree.SubElement(url_xml, 'path', attrib={})\n data_path.text = path\n data_tree = etree.SubElement(url_xml, 'tree', attrib={})\n data_tree.text = tree\n\n url_processor = URLProcessor(shot=int(shot), tree=tree, path=path)\n url = url_processor.get_url()\n url_el = etree.SubElement(url_xml, 'url', attrib={})\n url_el.text = url\n\n return HttpResponse(etree.tostring(url_xml),\n mimetype='text/xml; charset=utf-8')","def Home():\n return(\n f\"Hawaii Climate Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"and<br/>\"\n f\"/api/v1.0/<start>/<end>\"\n )","def find_image_url(lat_value, long_value):\n global custom_memory, custom_hit, custom_miss, total_custom_memory\n image_tuple = (lat_value, long_value)\n \n #When Latitude Longitude in Cache and HIT\n if image_tuple in custom_memory:\n custom_hit+=1\n custom_memory[image_tuple][1] = datetime.now()\n return custom_memory[image_tuple][0],\"hit\"\n \n #When Latitude Longitude NOT in Cache and MISS\n if len(custom_memory) < total_custom_memory:\n custom_miss+=1\n custom_memory[image_tuple] = [GetImageURL(*image_tuple), datetime.now()]\n return custom_memory[image_tuple][0], \"miss_when_not_full\"\n else:\n custom_memory = sorted([(key, list_vals) for key, list_vals in custom_memory.items()], key=lambda i:i[1][1], reverse=False)\n del custom_memory[0]\n custom_memory = dict(custom_memory)\n custom_miss+=1\n custom_memory[image_tuple] = [GetImageURL(*image_tuple), datetime.now()]\n return custom_memory[image_tuple][0], \"miss_when_after_full\"","def send_map_data():\n\n avg_lat = 37.75774\n avg_long = -122.43870\n bounds = {'lat': [-122.54, -122.35], 'lng': [37.67, 37.84]}\n center = {'lat': avg_lat, 'lng': avg_long}\n\n return jsonify({'map_center': center,\n 'map_bounds': bounds,\n })","def _make_url(self):\n ...","def search_geoloc_range_fixed_loc(request):\n\n patient_profile = PatientProfile.objects.get(user=request.user)\n fixed_location = patient_profile.location\n\n latitude = str(patient_profile.latitude)\n longitude = str(patient_profile.longitude)\n latlng = \"(\"+latitude+\", \"+longitude+\")\"\n print latlng\n \n template_var = {\n \"mylocation\": fixed_location,\n \"latlng\": latlng\n }\n\n return template_var","def buildSFOUrls(jd_start, jd_stop):\n url_list = []\n time_list = ['03z', '09z', '15z', '21z']\n delta = jd_stop-jd_start\n for i in range((delta.days)+1):\n model_file_date = jd_start + timedelta(days=i)\n base_url = ('http://opendap.co-ops.nos.noaa.gov/'\n 'thredds/dodsC/NOAA/SFBOFS/MODELS/')\n val_month, val_year, val_day = '', '', ''\n # Month.\n if model_file_date.month < 10:\n val_month = \"0\" + str(model_file_date.month)\n else:\n val_month = str(model_file_date.month)\n # Year.\n val_year = str(model_file_date.year)\n # Day.\n if model_file_date.day < 10:\n val_day = \"0\" + str(model_file_date.day)\n else:\n val_day = str(model_file_date.day)\n file_name = '/nos.sfbofs.stations.nowcast.'\n file_name += val_year + val_month + val_day\n for t in time_list:\n t_val = '.t' + t + '.nc'\n url_list.append(base_url + val_year + val_month +\n file_name + t_val)\n return url_list","def _makeWGSurl(WGSline) :\n if not WGSline.startswith(\"WGS \") :\n raise Exception(\"Line does not start with \\\"WGS \\\"\")\n accession = WGSline.split(\" \")[-1]\n accRoot = accession.split(\"-\")[0][0:6]\n url = \"http://www.ncbi.nlm.nih.gov/Traces/wgs/?download=\" + accRoot + \".1.gbff.gz\"\n return url","def makeRouteRequest(latLongs):\n global headersGlobal, routeURL_synchronous # get global variables\n\n key = variables.bingMapsAPIKey # api key\n # construct the URL\n url = routeURL_synchronous + \"wp.0=\" + str(latLongs[0][0]) + \",\" + str(latLongs[0][1]) + \"&wp.1=\" + str(\n latLongs[1][0]) + \",\" + str(latLongs[1][1]) + \"&key=\" + key\n\n request = requests.get(url, headers=headersGlobal) # make the request\n return request # return the request","def create_url(self, keywords, start, end, region=None, category=None):\n # Replace the '+' symbol in a keyword with '%2B'\n keywords = [re.sub(r'[+]', '%2B', kw) for kw in keywords]\n # Replace white spaces in a keyword with '%20'\n keywords = [re.sub(r'\\s', '%20', kw) for kw in keywords]\n # Define main components of the URL\n base = \"https://trends.google.com/trends/explore\"\n geo = f\"geo={region}&\" if region is not None else \"\"\n query = f\"q={','.join(keywords)}\"\n cat = f\"cat={category}&\" if category is not None else \"\"\n # Format the datetime objects to strings in the format used by google\n start_string = datetime.strftime(start, self._google_date_format)\n end_string = datetime.strftime(end, self._google_date_format)\n # Define the date-range component for the URL\n date = f\"date={start_string}%20{end_string}\"\n # Construct the URL\n url = f\"{base}?{cat}{date}&{geo}{query}\"\n return url","def mapdata(self):\n return {\n 'lat': str(self.location.latitude),\n 'lng': str(self.location.longitude),\n 'options': {\n 'icon': self.species.marker.url\n },\n 'data': {\n 'href': str(self.get_absolute_url())\n }\n }","def generate_xmap(x_len, y_len, all_cids, all_xcoords, all_ycoords):\r\n # Determine figure height and width\"\"\"\r\n img_height = x_len * 80\r\n img_width = y_len * 80\r\n\r\n # Write html script which allows for mouseover of labels\r\n xmap = []\r\n for cid, x, y in zip(all_cids, all_xcoords, all_ycoords):\r\n xmap.append(AREA_SRC % (x, img_height - y, cid, cid))\r\n\r\n return xmap, img_height, img_width","def map(request):\n # Test Comment\n assert isinstance(request, HttpRequest)\n return render(\n request,\n 'map.html',\n context_instance=RequestContext(request, {})\n )","def fetch_url_gevent(sitemap, base, url):\n print \"starting\", url\n markup = html.document_fromstring(requests.get(url).content)\n print \"got\", url\n markup.make_links_absolute(base)\n statics, links = getstatic(markup), getlinks_to(markup, base)\n sitemap.add_node(url, statics=statics, links=links)\n for link in links:\n sitemap.add_edge(url, link)\n return links","def createMap(title_in, file_in, fig_file_in, N, vmin, vmax, lon_in,\n lat_in, sss_in, colors, label='SSS [PSS]'):\n\n fig = plt.figure()\n ax = fig.add_subplot(111)\n ax.set_title(title_in)\n plt.figtext(1, 0, file_in, ha='right', va='bottom', fontsize=6)\n\n map = Basemap(projection='moll', resolution='l', lon_0=-50, ellps='WGS84', anchor='S')\n map.drawcoastlines(linewidth=0.01, antialiased=False)\n map.drawmapboundary(fill_color='white', linewidth=0.01)\n map.drawmeridians(np.arange(-180,181,60), labels=[0,0,0,0], linewidth=0.01, labelstyle=None)\n map.drawparallels(np.arange(-90,91,30), labels=[1,0,0,0], linewidth=0.01, labelstyle=None) \n map.fillcontinents(color='grey')\n\n ticks = np.linspace(vmin, vmax, N+1)\n \n lonout, z = map.shiftdata(lon_in, sss_in, lon_0=-50)\n lon, lat = np.meshgrid(lonout, lat_in)\n x, y = map(lon, lat)\n\n cmap = cm.get_cmap(colors, N)\n cmap.set_bad('1.0')\n cmap.set_under((0.0, 0.0, 0.25, 1.0))\n cmap.set_over((0.25, 0.0, 0.0, 1.0))\n\n pc = map.pcolormesh(x, y, z, vmin=vmin, vmax=vmax, cmap=cmap)\n cb = plt.colorbar(pc, shrink=0.8, orientation='horizontal', fraction=0.04, extend ='both', ticks=ticks)\n cb.set_label(label)\n plt.savefig(fig_file_in)\n logging.debug(fig_file_in +' .... created!' )\n plt.close()\n\n return None","def plot_html(lats, lons, zoom=11, heatmap=True, scatter=True):\n gmap = gmplot.GoogleMapPlotter(np.median(lats), np.median(lons), zoom=zoom)\n \n if heatmap: gmap.heatmap(lats, lons)\n if scatter: gmap.scatter(lats, lons, 'k', size=6, marker=False)\n gmap.draw(\"/Users/ulfaslak/Desktop/mymap.html\")","def create_maps(self,data,tod,mjd,coords):\n features = np.log10(self.getFeatures(data))/np.log10(2)\n special_idx = np.where((features==16))[0]\n # This is for getting the stare data on more recent\n # calibration observations.\n point_data = self.get_point_data(data,special_idx)\n \n cel_maps = self.create_single_map(tod,\n coords['ra'],\n coords['dec'],\n self.source_positions['ra'][coords['sky_data_flag']],\n self.source_positions['dec'][coords['sky_data_flag']])\n az_maps = self.create_single_map(tod,\n coords['az'],\n coords['el'],\n self.source_positions['az'][coords['sky_data_flag']],\n self.source_positions['el'][coords['sky_data_flag']])\n cel_maps= self.average_maps(cel_maps)\n az_maps = self.average_maps(az_maps)\n xygrid = np.meshgrid((np.arange(self.Nx)+0.5)*self.dx - self.Nx*self.dx/2.,\n (np.arange(self.Ny)+0.5)*self.dy - self.Ny*self.dy/2.)\n \n \n cel_maps['xygrid']=xygrid\n cel_maps['StareCoords']= {**point_data,'pa':np.nanmean(self.source_positions['pa'])}\n az_maps['xygrid']=xygrid\n az_maps['StareCoords'] = {**point_data,'pa':np.nanmean(self.source_positions['pa'])}\n return cel_maps,az_maps","def view_map():\n print(\"\"\"\n ____________________________________Client Rooms______________________\n| |1 Locker Rooms 2| 1 | 2 | |\n| |_________ ________| | | Dance |\n| | | |__| |__| Floor |\n| | | Hall |\n| Garage | Front | _______|_______ |\n| | Lobby | | |_ ____________|\n| | | | Storage |\n| | | Lounge |______________|\n| ______________ Car\n|___________________Front Entrance______________________| Allyway\n\"\"\")","def create_guardian_search_url(api_key, query, page, from_date, to_date):\n\n # format base url\n url = '%s?page-size=%s&show-fields=%s&q=%s&page=%s&api-key=%s' % (\n GUARDIAN_SEARCH_API, PAGE_SIZE, SHOW_FIELDS, query, page, api_key\n )\n\n # add from-date query, if exists\n if (from_date):\n url += '&from-date=%s' % (from_date)\n\n # add to-date query, if exists\n if (to_date):\n url += '&to-date=%s' % (to_date)\n\n return url"],"string":"[\n \"def generate_url(self):\\n if self.has_marker:\\n marker_param = f'mlat={self.mlat}&mlng={self.mlng}&'\\n else:\\n marker_param = ''\\n if self.start:\\n start_param = 'start=true&'\\n else:\\n start_param = ''\\n url = f'{MapController.MAP_URL}?{start_param}clat={self.clat}&clng={self.clng}&{marker_param}zoom={self.zoom}'\\n return url\",\n \"def get_static_map(start_lng, start_lat, end_lng, end_lat):\\r\\n geojson_str = get_map_directions(start_lng, start_lat, end_lng, end_lat)\\r\\n return (\\r\\n f\\\"https://api.mapbox.com/styles/v1/mapbox/streets-v11/static/\\\"\\r\\n f\\\"geojson({geojson_str})/auto/640x640?access_token={MAPBOX_TOKEN}\\\"\\r\\n ), geojson_str\",\n \"def small_map(self):\\n self.map_url = \\\"https://maps.googleapis.com/maps/api/staticmap?center={},{}&zoom=12&size=350x350&key={}\\\".format(self.lat, self.lng, api_key) \\n return (self.map_url)\",\n \"def google(self):\\r\\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\\r\\n middle = '&zoom=14&size=400x400&markers='\\r\\n suffix = '&key=AIzaSyD5nqmDGFH1SUZxJAYVtFHP7RNjjFE9CHg'\\r\\n marker = '+'.join(self.placeToSearch) # marker in google format, no space but + separator\\r\\n request = prefix + marker+middle+marker+suffix\\r\\n\\r\\n return request\",\n \"def generate_googlemaps(self):\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = format_extension[self.image_output.format]\\n args['publishurl'] = \\\"\\\" if self.options.url is None else self.options.url\\n args['copyright'] = self.options.copyright\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:v=\\\"urn:schemas-microsoft-com:vml\\\">\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv=\\\"content-type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\\n <script type=\\\"text/javascript\\\">\\n //<![CDATA[\\n\\n /*\\n * Constants for given map\\n * TODO: read it from tilemapresource.xml\\n */\\n\\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n var opacity = 0.75;\\n var map;\\n var ge;\\n var hybridOverlay;\\n\\n /*\\n * Create a Custom Opacity GControl\\n * https://github.com/mj10777/mapmbtilesgoogle-maps-overlay-opacity-control/\\n */\\n\\n var CTransparencyLENGTH = 58;\\n // maximum width that the knob can move (slide width minus knob width)\\n\\n function CTransparencyControl( overlay ) {\\n this.overlay = overlay;\\n this.opacity = overlay.getTileLayer().getOpacity();\\n }\\n CTransparencyControl.prototype = new GControl();\\n\\n // This function positions the slider to match the specified opacity\\n CTransparencyControl.prototype.setSlider = function(pos) {\\n var left = Math.round((CTransparencyLENGTH*pos));\\n this.slide.left = left;\\n this.knob.style.left = left+\\\"px\\\";\\n this.knob.style.top = \\\"0px\\\";\\n }\\n\\n // This function reads the slider and sets the overlay opacity level\\n CTransparencyControl.prototype.setOpacity = function() {\\n // set the global variable\\n opacity = this.slide.left/CTransparencyLENGTH;\\n this.map.clearOverlays();\\n this.map.addOverlay(this.overlay, { zPriority: 0 });\\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\\n this.map.addOverlay(hybridOverlay);\\n }\\n }\\n\\n // This gets called by the API when addControl(new CTransparencyControl())\\n CTransparencyControl.prototype.initialize = function(map) {\\n var that=this;\\n this.map = map;\\n\\n // Is this MSIE, if so we need to use AlphaImageLoader\\n var agent = navigator.userAgent.toLowerCase();\\n if ((agent.indexOf(\\\"msie\\\") > -1) && (agent.indexOf(\\\"opera\\\") < 1)){this.ie = true} else {this.ie = false}\\n\\n // create the background graphic as a <div> containing an image\\n var container = document.createElement(\\\"div\\\");\\n container.style.width=\\\"70px\\\";\\n container.style.height=\\\"21px\\\";\\n\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\\\";\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; ' +loader+ '\\\" ></div>';\\n } else {\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; background-image: url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\\\" ></div>';\\n }\\n\\n // create the knob as a GDraggableObject\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='https://github.com/mj10777/mapmbtiles/img/opacity-slider.png', sizingMethod='crop');\\\";\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.overflow=\\\"hidden\\\";\\n this.knob_img = document.createElement(\\\"div\\\");\\n this.knob_img.style.height=\\\"21px\\\";\\n this.knob_img.style.width=\\\"83px\\\";\\n this.knob_img.style.filter=loader;\\n this.knob_img.style.position=\\\"relative\\\";\\n this.knob_img.style.left=\\\"-70px\\\";\\n this.knob.appendChild(this.knob_img);\\n } else {\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.backgroundImage=\\\"url(https://github.com/mj10777/mapmbtiles/img/opacity-slider.png)\\\";\\n this.knob.style.backgroundPosition=\\\"-70px 0px\\\";\\n }\\n container.appendChild(this.knob);\\n this.slide=new GDraggableObject(this.knob, {container:container});\\n this.slide.setDraggableCursor('pointer');\\n this.slide.setDraggingCursor('pointer');\\n this.container = container;\\n\\n // attach the control to the map\\n map.getContainer().appendChild(container);\\n\\n // init slider\\n this.setSlider(this.opacity);\\n\\n // Listen for the slider being moved and set the opacity\\n GEvent.addListener(this.slide, \\\"dragend\\\", function() {that.setOpacity()});\\n //GEvent.addListener(this.container, \\\"click\\\", function( x, y ) { alert(x, y) });\\n\\n return container;\\n }\\n\\n // Set the default position for the control\\n CTransparencyControl.prototype.getDefaultPosition = function() {\\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\\n }\\n\\n /*\\n * Full-screen Window Resize\\n */\\n\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n // map.checkResize();\\n }\\n\\n\\n /*\\n * Main load function:\\n */\\n\\n function load() {\\n\\n if (GBrowserIsCompatible()) {\\n\\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\\n var gcr = GMapType.prototype.getCopyrights;\\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\\n return [\\\"%(copyright)s\\\"].concat(gcr.call(this,bounds,zoom));\\n }\\n\\n map = new GMap2( document.getElementById(\\\"map\\\"), { backgroundColor: '#fff' } );\\n\\n map.addMapType(G_PHYSICAL_MAP);\\n map.setMapType(G_PHYSICAL_MAP);\\n\\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\\n\\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\\n GEvent.addListener(map, \\\"maptypechanged\\\", function() {\\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\\n map.addOverlay(hybridOverlay);\\\"\\\"\\\" % args\\n if self.kml:\\n s += \\\"\\\"\\\"\\n } else if (map.getCurrentMapType() == G_SATELLITE_3D_MAP) {\\n var url = document.location.toString();\\n if (url.substr(0,4) != 'http') alert('You have to upload the tiles to a webserver to see the overlay in Google Earth Plugin');\\n if (!ge) map.getEarthInstance(getEarthInstanceCB);\\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n } else {\\n map.removeOverlay(hybridOverlay);\\n }\\n } );\\n\\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\\n var mercator = new GMercatorProjection(mapMaxZoom+1);\\n tilelayer.getTileUrl = function(tile,zoom) {\\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n var ymax = 1 << zoom;\\n var y = ymax - tile.y -1;\\n var tileBounds = new GLatLngBounds(\\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\\n );\\n if (mapBounds.intersects(tileBounds)) {\\n return zoom+\\\"/\\\"+tile.x+\\\"/\\\"+y+\\\".%(tileformat)s\\\";\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n // IE 7-: support for PNG alpha channel\\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\\n tilelayer.isPng = function() { return true;};\\n tilelayer.getOpacity = function() { return opacity; }\\n\\n overlay = new GTileLayerOverlay( tilelayer );\\n map.addOverlay(overlay);\\n\\n map.addControl(new GLargeMapControl3D());\\n map.addControl(new GHierarchicalMapTypeControl());\\n map.addControl(new CTransparencyControl( overlay ));\\n \\\"\\\"\\\" % args\\n if self.kml:\\n s += \\\"\\\"\\\"\\n map.addMapType(G_SATELLITE_3D_MAP);\\n \\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n\\n map.enableContinuousZoom();\\n map.enableScrollWheelZoom();\\n\\n map.setMapType(G_HYBRID_MAP);\\n }\\n resize();\\n }\\n \\\"\\\"\\\"\\n if self.kml:\\n s += \\\"\\\"\\\"\\n function getEarthInstanceCB(object) {\\n ge = object;\\n var url = document.location.toString();\\n var newurl = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\\n if (ge) {\\n var link = ge.createLink(\\\"\\\");\\n if (\\\"%(publishurl)s\\\") { link.setHref(\\\"%(publishurl)s/doc.kml\\\") }\\n else { link.setHref(newurl) };\\n var networkLink = ge.createNetworkLink(\\\"\\\");\\n networkLink.set(link, false, false);\\n ge.getFeatures().appendChild(networkLink);\\n } else {\\n // alert(\\\"Initialization of the Google Earth Plugin failed. You can still open the KML file in normal Google Earth.\\\");\\n // window.location = newurl; // JavaScript redirect to the URL of KML\\n }\\n }\\n \\\"\\\"\\\" % args\\n s += \\\"\\\"\\\"\\n onresize=function(){ resize(); };\\n\\n //]]>\\n </script>\\n </head>\\n <body onload=\\\"load()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"https://github.com/mj10777/mapmbtiles\\\">MapMbTiles</a>/<a href=\\\"http://www.klokan.cz/projects/gdal2mbtiles/\\\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n </body>\\n </html>\\n \\\"\\\"\\\" % args\\n\\n return s\",\n \"def generate_googlemaps(self):\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url\\n args['copyright'] = self.options.copyright\\n\\n s = r\\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\" xmlns:v=\\\"urn:schemas-microsoft-com:vml\\\">\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv=\\\"content-type\\\" content=\\\"text/html; charset=utf-8\\\"/>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s'></script>\\n <script>\\n //<![CDATA[\\n\\n /*\\n * Constants for given map\\n * TODO: read it from tilemapresource.xml\\n */\\n\\n var mapBounds = new GLatLngBounds(new GLatLng(%(south)s, %(west)s), new GLatLng(%(north)s, %(east)s));\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n var opacity = 0.75;\\n var map;\\n var hybridOverlay;\\n\\n /*\\n * Create a Custom Opacity GControl\\n * http://www.maptiler.org/google-maps-overlay-opacity-control/\\n */\\n\\n var CTransparencyLENGTH = 58;\\n // maximum width that the knob can move (slide width minus knob width)\\n\\n function CTransparencyControl( overlay ) {\\n this.overlay = overlay;\\n this.opacity = overlay.getTileLayer().getOpacity();\\n }\\n CTransparencyControl.prototype = new GControl();\\n\\n // This function positions the slider to match the specified opacity\\n CTransparencyControl.prototype.setSlider = function(pos) {\\n var left = Math.round((CTransparencyLENGTH*pos));\\n this.slide.left = left;\\n this.knob.style.left = left+\\\"px\\\";\\n this.knob.style.top = \\\"0px\\\";\\n }\\n\\n // This function reads the slider and sets the overlay opacity level\\n CTransparencyControl.prototype.setOpacity = function() {\\n // set the global variable\\n opacity = this.slide.left/CTransparencyLENGTH;\\n this.map.clearOverlays();\\n this.map.addOverlay(this.overlay, { zPriority: 0 });\\n if (this.map.getCurrentMapType() == G_HYBRID_MAP) {\\n this.map.addOverlay(hybridOverlay);\\n }\\n }\\n\\n // This gets called by the API when addControl(new CTransparencyControl())\\n CTransparencyControl.prototype.initialize = function(map) {\\n var that=this;\\n this.map = map;\\n\\n // Is this MSIE, if so we need to use AlphaImageLoader\\n var agent = navigator.userAgent.toLowerCase();\\n if ((agent.indexOf(\\\"msie\\\") > -1) && (agent.indexOf(\\\"opera\\\") < 1)){this.ie = true} else {this.ie = false}\\n\\n // create the background graphic as a <div> containing an image\\n var container = document.createElement(\\\"div\\\");\\n container.style.width=\\\"70px\\\";\\n container.style.height=\\\"21px\\\";\\n\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"filter:progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\\\";\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; ' +loader+ '\\\" ></div>';\\n } else {\\n container.innerHTML = '<div style=\\\"height:21px; width:70px; background-image: url(http://www.maptiler.org/img/opacity-slider.png)\\\" ></div>';\\n }\\n\\n // create the knob as a GDraggableObject\\n // Handle transparent PNG files in MSIE\\n if (this.ie) {\\n var loader = \\\"progid:DXImageTransform.Microsoft.AlphaImageLoader(src='http://www.maptiler.org/img/opacity-slider.png', sizingMethod='crop');\\\";\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.overflow=\\\"hidden\\\";\\n this.knob_img = document.createElement(\\\"div\\\");\\n this.knob_img.style.height=\\\"21px\\\";\\n this.knob_img.style.width=\\\"83px\\\";\\n this.knob_img.style.filter=loader;\\n this.knob_img.style.position=\\\"relative\\\";\\n this.knob_img.style.left=\\\"-70px\\\";\\n this.knob.appendChild(this.knob_img);\\n } else {\\n this.knob = document.createElement(\\\"div\\\");\\n this.knob.style.height=\\\"21px\\\";\\n this.knob.style.width=\\\"13px\\\";\\n this.knob.style.backgroundImage=\\\"url(http://www.maptiler.org/img/opacity-slider.png)\\\";\\n this.knob.style.backgroundPosition=\\\"-70px 0px\\\";\\n }\\n container.appendChild(this.knob);\\n this.slide=new GDraggableObject(this.knob, {container:container});\\n this.slide.setDraggableCursor('pointer');\\n this.slide.setDraggingCursor('pointer');\\n this.container = container;\\n\\n // attach the control to the map\\n map.getContainer().appendChild(container);\\n\\n // init slider\\n this.setSlider(this.opacity);\\n\\n // Listen for the slider being moved and set the opacity\\n GEvent.addListener(this.slide, \\\"dragend\\\", function() {that.setOpacity()});\\n //GEvent.addListener(this.container, \\\"click\\\", function( x, y ) { alert(x, y) });\\n\\n return container;\\n }\\n\\n // Set the default position for the control\\n CTransparencyControl.prototype.getDefaultPosition = function() {\\n return new GControlPosition(G_ANCHOR_TOP_RIGHT, new GSize(7, 47));\\n }\\n\\n /*\\n * Full-screen Window Resize\\n */\\n\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n // map.checkResize();\\n }\\n\\n\\n /*\\n * Main load function:\\n */\\n\\n function load() {\\n\\n if (GBrowserIsCompatible()) {\\n\\n // Bug in the Google Maps: Copyright for Overlay is not correctly displayed\\n var gcr = GMapType.prototype.getCopyrights;\\n GMapType.prototype.getCopyrights = function(bounds,zoom) {\\n return [\\\"%(copyright)s\\\"].concat(gcr.call(this,bounds,zoom));\\n }\\n\\n map = new GMap2( document.getElementById(\\\"map\\\"), { backgroundColor: '#fff' } );\\n\\n map.addMapType(G_PHYSICAL_MAP);\\n map.setMapType(G_PHYSICAL_MAP);\\n\\n map.setCenter( mapBounds.getCenter(), map.getBoundsZoomLevel( mapBounds ));\\n\\n hybridOverlay = new GTileLayerOverlay( G_HYBRID_MAP.getTileLayers()[1] );\\n GEvent.addListener(map, \\\"maptypechanged\\\", function() {\\n if (map.getCurrentMapType() == G_HYBRID_MAP) {\\n map.addOverlay(hybridOverlay);\\n } else {\\n map.removeOverlay(hybridOverlay);\\n }\\n } );\\n\\n var tilelayer = new GTileLayer(GCopyrightCollection(''), mapMinZoom, mapMaxZoom);\\n var mercator = new GMercatorProjection(mapMaxZoom+1);\\n tilelayer.getTileUrl = function(tile,zoom) {\\n if ((zoom < mapMinZoom) || (zoom > mapMaxZoom)) {\\n return \\\"http://www.maptiler.org/img/none.png\\\";\\n }\\n var ymax = 1 << zoom;\\n var y = ymax - tile.y -1;\\n var tileBounds = new GLatLngBounds(\\n mercator.fromPixelToLatLng( new GPoint( (tile.x)*256, (tile.y+1)*256 ) , zoom ),\\n mercator.fromPixelToLatLng( new GPoint( (tile.x+1)*256, (tile.y)*256 ) , zoom )\\n );\\n if (mapBounds.intersects(tileBounds)) {\\n return zoom+\\\"/\\\"+tile.x+\\\"/\\\"+y+\\\".png\\\";\\n } else {\\n return \\\"http://www.maptiler.org/img/none.png\\\";\\n }\\n }\\n // IE 7-: support for PNG alpha channel\\n // Unfortunately, the opacity for whole overlay is then not changeable, either or...\\n tilelayer.isPng = function() { return true;};\\n tilelayer.getOpacity = function() { return opacity; }\\n\\n overlay = new GTileLayerOverlay( tilelayer );\\n map.addOverlay(overlay);\\n\\n map.addControl(new GLargeMapControl());\\n map.addControl(new GHierarchicalMapTypeControl());\\n map.addControl(new CTransparencyControl( overlay ));\\n \\\"\\\"\\\" % args # noqa\\n if self.kml:\\n s += \\\"\\\"\\\"\\n map.addMapType(G_SATELLITE_3D_MAP);\\n map.getEarthInstance(getEarthInstanceCB);\\n \\\"\\\"\\\"\\n s += \\\"\\\"\\\"\\n\\n map.enableContinuousZoom();\\n map.enableScrollWheelZoom();\\n\\n map.setMapType(G_HYBRID_MAP);\\n }\\n resize();\\n }\\n \\\"\\\"\\\"\\n if self.kml:\\n s += \\\"\\\"\\\"\\n function getEarthInstanceCB(object) {\\n var ge = object;\\n\\n if (ge) {\\n var url = document.location.toString();\\n url = url.substr(0,url.lastIndexOf('/'))+'/doc.kml';\\n var link = ge.createLink(\\\"\\\");\\n if (\\\"%(publishurl)s\\\") { link.setHref(\\\"%(publishurl)s/doc.kml\\\") }\\n else { link.setHref(url) };\\n var networkLink = ge.createNetworkLink(\\\"\\\");\\n networkLink.setName(\\\"TMS Map Overlay\\\");\\n networkLink.setFlyToView(true);\\n networkLink.setLink(link);\\n ge.getFeatures().appendChild(networkLink);\\n } else {\\n // alert(\\\"You should open a KML in Google Earth\\\");\\n // add div with the link to generated KML... - maybe JavaScript redirect to the URL of KML?\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n s += \\\"\\\"\\\"\\n onresize=function(){ resize(); };\\n\\n //]]>\\n </script>\\n </head>\\n <body onload=\\\"load()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n </body>\\n </html>\\n \\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def build_url(start, end, transit_mode):\\n transit = \\\"\\\"\\n traffic = \\\"best_guess\\\"\\n depart = \\\"now\\\"\\n if transit_mode:\\n transit = transit_mode\\n direc_url = g_api_base_url + dir_url + \\\"origin=\\\" + start + \\\"&destination=\\\" + end + trans_url \\\\\\n + transit + goog_dir_key\\n dist_url = g_api_base_url + dis_url + units_i + or_dis_url + start + des_url + end + trans_url \\\\\\n + transit + traffic_url + traffic + depart_url + depart + goog_dis_key\\n direc_url = direc_url.replace(\\\" \\\",\\\"+\\\")\\n print(\\\"directions :\\\"+ direc_url)\\n dist_url = dist_url.replace(\\\" \\\",\\\"+\\\")\\n return direc_url, dist_url\",\n \"def get_static_google_map(filename_wo_extension, center=None, zoom=None, imgsize=\\\"640x640\\\", imgformat=\\\"png\\\",\\n maptype=\\\"roadmap\\\", markers=None):\\n\\n # assemble the URL\\n # base URL, append query params, separated by &\\n request = \\\"http://maps.google.com/maps/api/staticmap?\\\"\\n apiKey = os.getenv('GOOGLE_MAPS_API_KEY')\\n # if center and zoom are not given, the map will show all marker locations\\n request += \\\"key=%s&\\\" % apiKey\\n if center != None:\\n request += \\\"center=%s&\\\" % center\\n if zoom != None:\\n # zoom 0 (all of the world scale ) to 22 (single buildings scale)\\n request += \\\"zoom=%i&\\\" % zoom\\n\\n request += \\\"size=%ix%i&\\\" % (imgsize) # tuple of ints, up to 640 by 640\\n request += \\\"format=%s&\\\" % imgformat\\n request += \\\"bearing=90&\\\"\\n # request += \\\"maptype=%s&\\\" % maptype # roadmap, satellite, hybrid, terrain\\n\\n # add markers (location and style)\\n if markers != None:\\n for marker in markers:\\n request += \\\"%s&\\\" % marker\\n\\n request = request.rstrip('&')\\n # #request += \\\"mobile=false&\\\" # optional: mobile=true will assume the image is shown on a small screen (mobile device)\\n # request += \\\"sensor=false\\\" # must be given, deals with getting loction from mobile device\\n # try:\\n urllib.request.urlretrieve(request, filename_wo_extension)\",\n \"def get_driving_map(start_lng, start_lat, end_lng, end_lat):\\r\\n geojson_str = get_driving_directions(start_lng, start_lat, end_lng, end_lat)\\r\\n return (\\r\\n f\\\"https://api.mapbox.com/styles/v1/mapbox/streets-v11/static/\\\"\\r\\n f\\\"geojson({geojson_str})/auto/640x640?access_token={MAPBOX_TOKEN}\\\"\\r\\n ), geojson_str\",\n \"def build_maps():\\n return render_template(\\\"maps.html\\\")\",\n \"def get_trouble_spot_map(trouble_spot_lst):\\n lat_long_lst = []\\n for item in trouble_spot_lst:\\n latitude = item[0]\\n longitude = item[1]\\n married_lat_long = LAT_LONG_TMPL.format(lat=latitude, long=longitude)\\n lat_long_lst.append(married_lat_long)\\n\\n lat_long_lst_str = ''.join(lat_long_lst)\\n\\n result = URL_TMPL.format(key=API_KEY, marker=MARKER_SPEC, lat_long_lst=lat_long_lst_str)\\n return result\",\n \"def generate_leaflet(self):\\n\\n args = {}\\n args['title'] = self.options.title.replace('\\\"', '\\\\\\\\\\\"')\\n args['htmltitle'] = self.options.title\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['centerlon'] = (args['north'] + args['south']) / 2.\\n args['centerlat'] = (args['west'] + args['east']) / 2.\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['beginzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize # not used\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url # not used\\n args['copyright'] = self.options.copyright.replace('\\\"', '\\\\\\\\\\\"')\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html>\\n <html lang=\\\"en\\\">\\n <head>\\n <meta charset=\\\"utf-8\\\">\\n <meta name='viewport' content='width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no' />\\n <title>%(htmltitle)s</title>\\n\\n <!-- Leaflet -->\\n <link rel=\\\"stylesheet\\\" href=\\\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.css\\\" />\\n <script src=\\\"http://cdn.leafletjs.com/leaflet-0.7.5/leaflet.js\\\"></script>\\n\\n <style>\\n body { margin:0; padding:0; }\\n body, table, tr, td, th, div, h1, h2, input { font-family: \\\"Calibri\\\", \\\"Trebuchet MS\\\", \\\"Ubuntu\\\", Serif; font-size: 11pt; }\\n #map { position:absolute; top:0; bottom:0; width:100%%; } /* full size */\\n .ctl {\\n padding: 2px 10px 2px 10px;\\n background: white;\\n background: rgba(255,255,255,0.9);\\n box-shadow: 0 0 15px rgba(0,0,0,0.2);\\n border-radius: 5px;\\n text-align: right;\\n }\\n .title {\\n font-size: 18pt;\\n font-weight: bold;\\n }\\n .src {\\n font-size: 10pt;\\n }\\n\\n </style>\\n\\n </head>\\n <body>\\n\\n <div id=\\\"map\\\"></div>\\n\\n <script>\\n /* **** Leaflet **** */\\n\\n // Base layers\\n // .. OpenStreetMap\\n var osm = L.tileLayer('http://{s}.tile.osm.org/{z}/{x}/{y}.png', {attribution: '© <a href=\\\"http://osm.org/copyright\\\">OpenStreetMap</a> contributors'});\\n\\n // .. CartoDB Positron\\n var cartodb = L.tileLayer('http://{s}.basemaps.cartocdn.com/light_all/{z}/{x}/{y}.png', {attribution: '© <a href=\\\"http://www.openstreetmap.org/copyright\\\">OpenStreetMap</a> contributors, © <a href=\\\"http://cartodb.com/attributions\\\">CartoDB</a>'});\\n\\n // .. OSM Toner\\n var toner = L.tileLayer('http://{s}.tile.stamen.com/toner/{z}/{x}/{y}.png', {attribution: 'Map tiles by <a href=\\\"http://stamen.com\\\">Stamen Design</a>, under <a href=\\\"http://creativecommons.org/licenses/by/3.0\\\">CC BY 3.0</a>. Data by <a href=\\\"http://openstreetmap.org\\\">OpenStreetMap</a>, under <a href=\\\"http://www.openstreetmap.org/copyright\\\">ODbL</a>.'});\\n\\n // .. White background\\n var white = L.tileLayer(\\\"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAQAAAAEAAQMAAABmvDolAAAAA1BMVEX///+nxBvIAAAAH0lEQVQYGe3BAQ0AAADCIPunfg43YAAAAAAAAAAA5wIhAAAB9aK9BAAAAABJRU5ErkJggg==\\\");\\n\\n // Overlay layers (TMS)\\n var lyr = L.tileLayer('./{z}/{x}/{y}.%(tileformat)s', {tms: true, opacity: 0.7, attribution: \\\"%(copyright)s\\\"});\\n\\n // Map\\n var map = L.map('map', {\\n center: [%(centerlon)s, %(centerlat)s],\\n zoom: %(beginzoom)s,\\n minZoom: %(minzoom)s,\\n maxZoom: %(maxzoom)s,\\n layers: [osm]\\n });\\n\\n var basemaps = {\\\"OpenStreetMap\\\": osm, \\\"CartoDB Positron\\\": cartodb, \\\"Stamen Toner\\\": toner, \\\"Without background\\\": white}\\n var overlaymaps = {\\\"Layer\\\": lyr}\\n\\n // Title\\n var title = L.control();\\n title.onAdd = function(map) {\\n this._div = L.DomUtil.create('div', 'ctl title');\\n this.update();\\n return this._div;\\n };\\n title.update = function(props) {\\n this._div.innerHTML = \\\"%(title)s\\\";\\n };\\n title.addTo(map);\\n\\n // Note\\n var src = 'Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>';\\n var title = L.control({position: 'bottomleft'});\\n title.onAdd = function(map) {\\n this._div = L.DomUtil.create('div', 'ctl src');\\n this.update();\\n return this._div;\\n };\\n title.update = function(props) {\\n this._div.innerHTML = src;\\n };\\n title.addTo(map);\\n\\n\\n // Add base layers\\n L.control.layers(basemaps, overlaymaps, {collapsed: false}).addTo(map);\\n\\n // Fit to overlay bounds (SW and NE points with (lat, lon))\\n map.fitBounds([[%(south)s, %(east)s], [%(north)s, %(west)s]]);\\n\\n </script>\\n\\n </body>\\n </html>\\n\\n \\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def calc_url(self):\\n place = self._get_first_place()[0]\\n path = \\\"\\\"\\n # First see if we are in or near Sweden or Denmark\\n # Change country to upper case\\n location = get_main_location(self.database, place)\\n country = location.get(PlaceType.COUNTRY, '').upper().strip()\\n country_given = (country in MAP_NAMES_SWEDEN or \\\\\\n country in MAP_NAMES_DENMARK) and (country != \\\"\\\")\\n # if no country given, check if we might be in the vicinity defined by\\n # 54 33' 0\\\" < lat < 66 9' 0\\\", 54.55 and 69.05\\n # 8 3' 0\\\" < long < 24 9' 0\\\", 8.05 and 24.15 \\n latitude, longitude = self._lat_lon(place)\\n if latitude is None or longitude is None:\\n coord_ok = False\\n else:\\n latitude = float(latitude) \\n longitude = float(longitude)\\n # Check if coordinates are inside Sweden and Denmark\\n if (54.55 < latitude < 69.05) and (8.05 < longitude < 24.15):\\n coord_ok = True\\n else:\\n msg2 = _(\\\"Latitude not within '54.55' to '69.05'\\\\n\\\") + \\\\\\n _(\\\"Longitude not within '8.05' to '24.15'\\\")\\n WarningDialog(_(\\\"Eniro map not available\\\"), msg2 )\\n return\\n\\n if coord_ok:\\n place_title = _build_title(self.database, place)\\n place_city = _build_city(self.database, place)\\n x_coord, y_coord = self._lat_lon(place, format=\\\"RT90\\\")\\n # Set zoom level to 5 if Sweden/Denmark, others 3\\n zoom = 5\\n if not country_given:\\n zoom = 3\\n path = \\\"http://www.eniro.se/partner.fcgi?pis=1&x=%s&y=%s\\\" \\\\\\n \\\"&zoom_level=%i&map_size=0&title=%s&city=%s&partner=gramps\\\"\\n # Note x and y are swapped!\\n path = path % (y_coord , x_coord, zoom, place_title, place_city)\\n self.url = path.replace(\\\" \\\",\\\"%20\\\")\\n return\\n\\n place_area = _build_area(self.database, place)\\n if country_given and place_area:\\n if country in MAP_NAMES_SWEDEN:\\n path = \\\"http://kartor.eniro.se/query?&what=map_adr&mop=aq\\\" \\\\\\n \\\"&geo_area=%s&partner=gramps\\\"\\n path = path % (place_area)\\n self.url = path.replace(\\\" \\\",\\\"%20\\\")\\n return\\n else:\\n WarningDialog(_(\\\"Eniro map not available\\\"), \\\\\\n _(\\\"Coordinates needed in Denmark\\\") )\\n self.url = \\\"\\\"\\n return\\n\\n WarningDialog(_(\\\"Eniro map not available\\\"), \\n _(\\\"Latitude and longitude,\\\\n\\\" \\\\\\n \\\"or street and city needed\\\") )\\n return\",\n \"def generate_geo_map(start_date, end_date):\\n start_time = dt.datetime.now()\\n\\n start_date = dt.datetime.strptime(start_date.split('T')[0], '%Y-%m-%d') # Convert strings to datetime objects\\n end_date = dt.datetime.strptime(end_date.split('T')[0], '%Y-%m-%d')\\n\\n filtered_data = filter_dataframe(df, start_date, end_date)\\n dff = filtered_data\\n\\n traces = []\\n\\n data = [ dict(\\n type = 'scattermapbox',\\n lon = dff['lat'],\\n lat = dff['lon'],\\n text = dff['timestamp'],\\n mode = 'markers',\\n marker = dict(\\n size = 8,\\n opacity = 0.8,\\n color = 'orange'\\n ))]\\n\\n # relayoutData is None by default, and {'autosize': True} without relayout action\\n # if main_graph_layout is not None and selector is not None and \\\"locked\\\" in selector:\\n # if \\\"mapbox.center\\\" in main_graph_layout.keys():\\n # lon = float(main_graph_layout[\\\"mapbox.center\\\"][\\\"lon\\\"])\\n # lat = float(main_graph_layout[\\\"mapbox.center\\\"][\\\"lat\\\"])\\n # zoom = float(main_graph_layout[\\\"mapbox.zoom\\\"])\\n # layout[\\\"mapbox\\\"][\\\"center\\\"][\\\"lon\\\"] = lon\\n # layout[\\\"mapbox\\\"][\\\"center\\\"][\\\"lat\\\"] = lat\\n # layout[\\\"mapbox\\\"][\\\"zoom\\\"] = zoom\\n\\n print('generate_geo_map:', (dt.datetime.now()-start_time).total_seconds())\\n\\n figure = dict(data=data, layout=layout)\\n return figure\",\n \"def generate_openlayers( self ):\\n\\n args = {}\\n args['title'] = self.options.title\\n args['googlemapskey'] = self.options.googlekey\\n args['yahooappid'] = self.options.yahookey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = format_extension[self.image_output.format]\\n if self.image_output.format == \\\"PNG\\\":\\n args['has_alpha'] = 'true'\\n else:\\n args['has_alpha'] = 'false'\\n args['publishurl'] = \\\"\\\" if self.options.url is None else self.options.url\\n args['copyright'] = self.options.copyright\\n if self.options.profile in ('raster', 'gearth'):\\n args['rasterzoomlevels'] = self.tmaxz+1\\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\\n\\n s = \\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml>\\\"\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n </style>\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n <script src='http://dev.virtualearth.net/mapcontrol/mapcontrol.ashx?v=6.1'></script>\\n <script src='http://maps.google.com/maps?file=api&v=2&key=%(googlemapskey)s' type='text/javascript'></script>\\n <script src=\\\"http://api.maps.yahoo.com/ajaxymap?v=3.0&appid=%(yahooappid)s\\\"></script>\\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n <script src=\\\"http://www.openlayers.org/api/2.7/OpenLayers.js\\\" type=\\\"text/javascript\\\"></script>\\n <script type=\\\"text/javascript\\\">\\n var map;\\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n\\n // avoid pink tiles\\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\\n OpenLayers.Util.onImageLoadErrorColor = \\\"transparent\\\";\\n\\n function init(){\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:900913\\\"),\\n displayProjection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n units: \\\"m\\\",\\n maxResolution: 156543.0339,\\n maxExtent: new OpenLayers.Bounds(-20037508, -20037508, 20037508, 20037508.34)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n // create Google Mercator layers\\n var gmap = new OpenLayers.Layer.Google(\\\"Google Streets\\\",\\n { sphericalMercator: true, numZoomLevels: 20} );\\n var gsat = new OpenLayers.Layer.Google(\\\"Google Satellite\\\",\\n {type: G_SATELLITE_MAP, sphericalMercator: true, numZoomLevels: 20} );\\n var ghyb = new OpenLayers.Layer.Google(\\\"Google Hybrid\\\",\\n {type: G_HYBRID_MAP, sphericalMercator: true, numZoomLevels: 20});\\n var gter = new OpenLayers.Layer.Google(\\\"Google Terrain\\\",\\n {type: G_PHYSICAL_MAP, sphericalMercator: true, numZoomLevels: 20 });\\n\\n // create Virtual Earth layers\\n OpenLayers.Layer.VirtualEarth.prototype.MAX_ZOOM_LEVEL=19;\\n OpenLayers.Layer.VirtualEarth.prototype.RESOLUTIONS=OpenLayers.Layer.Google.prototype.RESOLUTIONS\\n var veroad = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Roads\\\",\\n {'type': VEMapStyle.Road, 'sphericalMercator': true, numZoomLevels: 20});\\n var veaer = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Aerial\\\",\\n {'type': VEMapStyle.Aerial, 'sphericalMercator': true, numZoomLevels: 20 });\\n var vehyb = new OpenLayers.Layer.VirtualEarth(\\\"Virtual Earth Hybrid\\\",\\n {'type': VEMapStyle.Hybrid, 'sphericalMercator': true});\\n\\n // create Yahoo layer\\n var yahoo = new OpenLayers.Layer.Yahoo(\\\"Yahoo Street\\\",\\n {'sphericalMercator': true});\\n var yahoosat = new OpenLayers.Layer.Yahoo(\\\"Yahoo Satellite\\\",\\n {'type': YAHOO_MAP_SAT, 'sphericalMercator': true});\\n var yahoohyb = new OpenLayers.Layer.Yahoo(\\\"Yahoo Hybrid\\\",\\n {'type': YAHOO_MAP_HYB, 'sphericalMercator': true});\\n\\n // create OSM/OAM layer\\n var osm = new OpenLayers.Layer.TMS( \\\"OpenStreetMap\\\",\\n \\\"http://tile.openstreetmap.org/\\\",\\n { type: 'png', getURL: osm_getTileURL, displayOutsideMaxExtent: true,\\n attribution: '<a href=\\\"http://www.openstreetmap.org/\\\">OpenStreetMap</a>'} );\\n var oam = new OpenLayers.Layer.TMS( \\\"OpenAerialMap\\\",\\n \\\"http://tile.openaerialmap.org/tiles/1.0.0/openaerialmap-900913/\\\",\\n { type: 'png', getURL: osm_getTileURL } );\\n\\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n { // url: '', serviceVersion: '.', layername: '.',\\n type: '%(tileformat)s', getURL: overlay_getTileURL, alpha: %(has_alpha)s,\\n isBaseLayer: false\\n });\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n map.addLayers([gmap, gsat, ghyb, gter, veroad, veaer, vehyb,\\n yahoo, yahoosat, yahoohyb, osm, oam,\\n tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds.transform(map.displayProjection, map.projection ) );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n projection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n maxResolution: 0.703125,\\n maxExtent: new OpenLayers.Bounds(-180, -90, 180, 90)\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n layer = new OpenLayers.Layer.WMS( \\\"Blue Marble\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'satellite' } );\\n map.addLayer(layer);\\n wms = new OpenLayers.Layer.WMS( \\\"VMap0\\\",\\n \\\"http://labs.metacarta.com/wms-c/Basic.py?\\\", {layers: 'basic', format: 'image/png' } );\\n map.addLayer(wms);\\n\\n var tmsoverlay = new OpenLayers.Layer.TMS( \\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL,\\n isBaseLayer: false\\n });\\n map.addLayer(tmsoverlay);\\n if (OpenLayers.Util.alphaHack() == false) { tmsoverlay.setOpacity(0.7); }\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster', 'gearth'):\\n s += \\\"\\\"\\\"\\n var options = {\\n controls: [],\\n maxExtent: new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s ),\\n maxResolution: %(rastermaxresolution)f,\\n numZoomLevels: %(rasterzoomlevels)d\\n };\\n map = new OpenLayers.Map('map', options);\\n\\n var layer = new OpenLayers.Layer.TMS( \\\"TMS Layer\\\",\\\"\\\",\\n { url: '', serviceVersion: '.', layername: '.', alpha: %(has_alpha)s,\\n type: '%(tileformat)s', getURL: overlay_getTileURL\\n });\\n map.addLayer(layer);\\n map.zoomToExtent( mapBounds );\\n \\\"\\\"\\\" % args\\n\\n\\n s += \\\"\\\"\\\"\\n map.addControl(new OpenLayers.Control.PanZoomBar());\\n map.addControl(new OpenLayers.Control.MousePosition());\\n map.addControl(new OpenLayers.Control.MouseDefaults());\\n map.addControl(new OpenLayers.Control.KeyboardDefaults());\\n }\\n \\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n function osm_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((this.maxExtent.top - bounds.top) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var limit = Math.pow(2, z);\\n\\n if (y < 0 || y >= limit) {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n } else {\\n x = ((x %% limit) + limit) %% limit;\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n }\\n }\\n\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (this.map.baseLayer.name == 'Virtual Earth Roads' || this.map.baseLayer.name == 'Virtual Earth Aerial' || this.map.baseLayer.name == 'Virtual Earth Hybrid') {\\n z = z + 1;\\n }\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom ) {\\n //console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (mapBounds.intersectsBounds( bounds ) && z >= mapMinZoom && z <= mapMaxZoom) {\\n // console.log( this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type);\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n elif self.options.profile in ('raster','gearth'):\\n s += \\\"\\\"\\\"\\n function overlay_getTileURL(bounds) {\\n var res = this.map.getResolution();\\n var x = Math.round((bounds.left - this.maxExtent.left) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.maxExtent.bottom) / (res * this.tileSize.h));\\n var z = this.map.getZoom();\\n if (x >= 0 && y >= 0) {\\n return this.url + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n } else {\\n return \\\"https://github.com/mj10777/mapmbtiles/img/none.png\\\";\\n }\\n }\\n \\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"https://github.com/mj10777/mapmbtiles\\\">MapMbTiles</a>/<a href=\\\"http://www.klokan.cz/projects/gdal2mbtiles/\\\">GDAL2MbTiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args\\n\\n return s\",\n \"def build_url(self):\\n return self.data_url.format(latitude=self.latitude, longitude=self.longitude)\",\n \"def map_link(self):\\n return self.map_url.format(latitude=self.latitude, longitude=self.longitude)\",\n \"def build_url(ori_lon, ori_lat, des_lon, des_lat, year, month, day, hour, minute, args={}):\\n options = dict()\\n with open(option_file, 'r', newline='') as file:\\n # Read the options file\\n for line in file:\\n if line[0] == '#': # if the first character of a line is '#' skip it\\n continue\\n splited_line = line.rstrip().split(':')\\n if len(splited_line) < 2: # if it is a line with no ':'\\n continue\\n options[splited_line[0]] = splited_line[1]\\n base_URL = 'localhost:' + port + '/otp/routers/default/plan'\\n fromPlace = ori_lon + ',' + ori_lat\\n toPlace = des_lon + ',' + des_lat\\n date = year + '/' + month + '/' + day\\n time = hour + ':' + minute + ':00'\\n\\n url = 'http://' + base_URL + '?fromPlace=' + fromPlace + '&toPlace=' + toPlace + '&date=' + date + '&time=' + time\\n for option_name in options.keys():\\n option = options[option_name]\\n url += '&' + option_name + '=' + option\\n if not 'mode' in url:\\n url += '&mode=TRANSIT,WALK'\\n for key in args.keys():\\n url+= '&' + key + '=' + args[key]\\n\\n return url\",\n \"def map():\\n return render_template('map.html')\",\n \"def visualize(g):\\n url = \\\"http://www.gcmap.com/mapui?P=\\\"\\n routes = []\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n route = (g.city_dict[key].get_code(), flight[0])\\n if(route not in routes):\\n routes.append(route)\\n \\n for flight in routes:\\n url = url + flight[0] + \\\"-\\\" + flight[1]\\n url = url + \\\",+\\\"\\n \\n url = url[:-2]\\n return url\",\n \"def map():\\n\\n return render_template(\\\"map.html\\\")\",\n \"def mobilize_map_url(value, args=None):\\n url = value\\n # url = value.replace(\\\"maps.google.com\\\", 'm.google.com')\\n return url # + \\\"&source=mobilesearchapp\\\"\",\n \"def write_prefix(self, lat, lon):\\n # Open the Maps API and center at the mean of the data\\n self.fd.write(\\\"\\\"\\\"<!DOCTYPE html>\\n <html>\\n <head>\\n <meta name=\\\"viewport\\\" content=\\\"initial-scale=1.0, user-scalable=no\\\" />\\n <style type=\\\"text/css\\\">\\n html { height: 100%% }\\n body { height: 100%%; margin: 0px; padding: 0px }\\n </style>\\n <script type=\\\"text/javascript\\\"\\n src=\\\"http://maps.google.com/maps/api/js?sensor=false\\\">\\n </script>\\n <script type=\\\"text/javascript\\\">\\n function initialize() {\\n var myLatlng = new google.maps.LatLng(%f, %f);\\n var myOptions = {\\n zoom: 14,\\n center: myLatlng,\\n mapTypeId: google.maps.MapTypeId.ROADMAP\\n }\\n var map = new google.maps.Map(document.getElementById(\\\"map_canvas\\\"), myOptions);\\n var infowindow = new google.maps.InfoWindow({\\n content: 'No EXIF Data'\\n });\\n var contentStrings = {}\\n \\\"\\\"\\\" % (lat, lon))\",\n \"def walking():\\r\\n name = request.args[\\\"address\\\"]\\r\\n end_name=request.args[\\\"end_point\\\"]\\r\\n end_lng = request.args[\\\"end_lng\\\"]\\r\\n end_lat = request.args[\\\"end_lat\\\"]\\r\\n end_lng = float(end_lng)\\r\\n end_lat = float(end_lat)\\r\\n start_lng=get_address(name)[1]\\r\\n start_lat=get_address(name)[0]\\r\\n\\r\\n\\r\\n #get coordinates of start and end point\\r\\n map_directions, geojson_str = get_static_map(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n logging.warning(\\\"Map directions %s\\\", str(map_directions))\\r\\n\\r\\n\\r\\n #retrieve instructions\\r\\n instructions = get_map_instructions(\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lat,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n )\\r\\n\\r\\n\\r\\n # generate interactive map\\r\\n return render_template(\\r\\n \\\"page4.html\\\",\\r\\n mapbox_token=MAPBOX_TOKEN,\\r\\n geojson_str=geojson_str,\\r\\n end_name=end_name,\\r\\n name=name,\\r\\n start_lng=start_lng,\\r\\n start_lat=start_lng,\\r\\n end_lng=end_lng,\\r\\n end_lat=end_lat,\\r\\n center_lng=(start_lng + end_lng) / 2,\\r\\n center_lat=(start_lat + end_lat) / 2,\\r\\n instructions=instructions,\\r\\n method = 'Walking'\\r\\n )\",\n \"def plot_gps_html(gps_list):\\n import gmplot\\n import matplotlib as mpl\\n import vtool as vt\\n\\n import wbia.plottool as pt\\n\\n pt.qt4ensure()\\n\\n lat = gps_list.T[0]\\n lon = gps_list.T[1]\\n\\n # Get extent of\\n bbox = vt.bbox_from_verts(gps_list)\\n centerx, centery = vt.bbox_center(bbox)\\n\\n gmap = gmplot.GoogleMapPlotter(centerx, centery, 13)\\n color = mpl.colors.rgb2hex(pt.ORANGE)\\n gmap.scatter(lat, lon, color=color, size=100, marker=False)\\n gmap.draw('mymap.html')\\n ut.startfile('mymap.html')\\n\\n # # Scale\\n # bbox = vt.scale_bbox(bbox, 10.0)\\n # extent = vt.extent_from_bbox(bbox)\\n # basemap_extent = dict(llcrnrlon=extent[2], urcrnrlon=extent[3],\\n # llcrnrlat=extent[0], urcrnrlat=extent[1])\\n # # Whole globe\\n # #basemap_extent = dict(llcrnrlon=0, llcrnrlat=-80,\\n # # urcrnrlon=360, urcrnrlat=80)\\n\\n # from mpl_toolkits.basemap import Basemap\\n # from matplotlib.colors import LightSource # NOQA\\n # from mpl_toolkits.basemap import shiftgrid, cm # NOQA\\n # from netCDF4 import Dataset\\n # # Read information to make background pretty\\n # logger.info('Grab topo information')\\n # etopodata = Dataset('http://ferret.pmel.noaa.gov/thredds/dodsC/data/PMEL/etopo5.nc')\\n # logger.info('Read topo information')\\n # topoin = etopodata.variables['ROSE'][:]\\n # lons = etopodata.variables['ETOPO05_X'][:]\\n # lats = etopodata.variables['ETOPO05_Y'][:]\\n # # shift data so lons go from -180 to 180 instead of 20 to 380.\\n # logger.info('Shift data')\\n # topoin, lons = shiftgrid(180., topoin, lons, start=False)\\n\\n # logger.info('Make figure')\\n # fnum = pt.ensure_fnum(None)\\n # fig = pt.figure(fnum=fnum, doclf=True, docla=True) # NOQA\\n # logger.info('Draw projection')\\n # m = Basemap(projection='mill', **basemap_extent)\\n # # setup Lambert Conformal basemap.\\n # #m = Basemap(projection='cea',resolution='h', **basemap_extent)\\n\\n # # transform to nx x ny regularly spaced 5km native projection grid\\n # logger.info('projection grid')\\n # nx = int((m.xmax - m.xmin) / 5000.) + 1\\n # ny = int((m.ymax - m.ymin) / 5000.) + 1\\n # topodat = m.transform_scalar(topoin, lons, lats, nx, ny)\\n\\n # # plot image over map with imshow.\\n # im = m.imshow(topodat, cm.GMT_haxby) # NOQA\\n # # draw coastlines and political boundaries.\\n # m.drawcoastlines()\\n # m.drawcountries()\\n # m.drawstates()\\n\\n # transform to nx x ny regularly spaced 5km native projection grid\\n # ls = LightSource(azdeg=90, altdeg=20)\\n # rgb = ls.shade(topodat, cm.GMT_haxby)\\n # im = m.imshow(rgb)\\n # draw coastlines and political boundaries.\\n\\n # m.drawcoastlines()\\n # m.drawcountries()\\n # m.drawstates()\\n\\n # draw a boundary around the map, fill the background.\\n # this background will end up being the ocean color, since\\n # the continents will be drawn on top.\\n # m.bluemarble()\\n # m.drawmapboundary(fill_color='aqua')\\n # m.fillcontinents(color='coral', lake_color='aqua')\\n # Convert GPS to projected coordinates\\n # x1, y1 = m(lon, lat) # convert to meters # lon==X, lat==Y\\n # m.plot(x1, y1, '*', markersize=10)\\n # fig.zoom_fac = pt.zoom_factory()\\n # fig.pan_fac = pt.pan_factory()\\n # fig.show()\",\n \"def map_image(res):\\n # constants\\n MAP_URL = \\\"https://maps.googleapis.com/maps/api/staticmap\\\"\\n SIZE = \\\"400x400\\\"\\n\\n polygon_path = mh.get_polygon_path(res)\\n origin = mh.get_latlon(mh.get_origin(res))\\n destination = mh.get_latlon(mh.get_destination(res))\\n params = {\\n \\\"size\\\": SIZE,\\n \\\"path\\\": f\\\"enc:{polygon_path}\\\",\\n \\\"markers\\\": [f\\\"color:red|label:X|{destination}\\\", f\\\"size:small|color:blue|{origin}\\\"],\\n \\\"key\\\": key\\n }\\n img_resp = requests.get(url=MAP_URL, params=params)\\n return img_resp.url\",\n \"def download_map(latitude, longitude, outname):\\n url1 = \\\"https://maps.googleapis.com/maps/api/staticmap?center={:.8f},{:.8f}&zoom=8&maptype=satellite&size=1000x1000&scale=4\\\".format(latitude,longitude)\\n buffer1 = StringIO(urllib.urlopen(url1).read())\\n image = Image.open(buffer1)\\n image.save('{}.png'.format(outname))\",\n \"def map_locations(args, number_publications, numbers,\\n links_locations_and_timestamps, gps_coordinates,\\n countrycodes_for_js, continents_for_js):\\n templateLoader = jinja2.FileSystemLoader(searchpath=\\\"./\\\")\\n templateEnv = jinja2.Environment(loader=templateLoader)\\n template = templateEnv.get_template(\\\"template.html\\\")\\n outputText = template.render(\\n target_account=args.target_account,\\n publications_number=number_publications,\\n retrieved_number=len(links_locations_and_timestamps),\\n mapped_number=numbers[0],\\n links=str([x[0] for x in links_locations_and_timestamps]),\\n errors_number=len(links_locations_and_timestamps) - numbers[0],\\n places=str([x[1] for x in links_locations_and_timestamps]),\\n timestamps=str([x[2] for x in links_locations_and_timestamps]),\\n locations=str(gps_coordinates),\\n countrycodes=str(countrycodes_for_js),\\n continents=str(continents_for_js))\\n\\n with open(\\n \\\"output/\\\" + args.target_account + \\\"/\\\" + args.target_account +\\n \\\"_instaloctrack_map.html\\\", \\\"w\\\") as f:\\n f.write(outputText)\\n f.close()\\n print(Fore.WHITE + \\\"Map with all the markers was written to:\\\" +\\n Fore.GREEN + \\\" output/\\\" + args.target_account + \\\"/\\\" +\\n args.target_account + \\\"_instaloctrack_map.html\\\")\",\n \"def generate_garmin_kml(self, d ):\\n return (\\\"\\\"\\\"\\n <GroundOverlay>\\n <Icon>\\n <href>%(image_url)s</href>\\n <DrawOrder>%(draw_order)d</DrawOrder>\\n </Icon>\\n <LatLonBox>\\n <north>%(north).14f</north>\\n <south>%(south).14f</south>\\n <east>%(east).14f</east>\\n <west>%(west).14f</west>\\n </LatLonBox>\\n </GroundOverlay>\\\"\\\"\\\" % d )\",\n \"def get_map_instructions(start_lng, start_lat, end_lng, end_lat):\\r\\n directions_resp = requests.get(\\r\\n f\\\"https://api.mapbox.com/directions/v5/mapbox/walking/{start_lng},{start_lat};{end_lng},{end_lat}\\\",\\r\\n params={\\r\\n \\\"access_token\\\": MAPBOX_TOKEN,\\r\\n \\\"geometries\\\": \\\"geojson\\\",\\r\\n \\\"steps\\\": \\\"true\\\",\\r\\n \\\"alternatives\\\": \\\"true\\\",\\r\\n },\\r\\n )\\r\\n instructions=[]\\r\\n for step in directions_resp.json()['routes'][0]['legs'][0]['steps']:\\r\\n instructions.append(f\\\"{step['maneuver']['instruction']}\\\")\\r\\n #listToStr = '<br>'.join(map(str, instruction))\\r\\n return instructions\",\n \"def CreateTargetGeoMap(latS, latN, lonW, lonE, latlen, lonlen):\\n\\n lat_grid = np.linspace(latS, latN, latlen)\\n lon_grid = np.linspace(lonW, lonE, lonlen)\\n\\n return lat_grid,lon_grid\",\n \"def map_page():\\n m = Map() # Create map html\\n return render_template('index.html') # pulls map html using jinja2\",\n \"def getGoogleMap(self, lat, lng, wTileN, hTileN, zoom):\\n start_x, start_y = self.getStartTlXY(lat, lng, zoom)\\n width, height = 256 * wTileN, 256 * hTileN\\n map_img = Image.new('RGB', (width, height))\\n for x in range(0, wTileN):\\n for y in range(0, hTileN):\\n url = 'https://mt0.google.com/vt?x=' + \\\\\\n str(start_x+x)+'&y='+str(start_y+y)+'&z='+str(zoom)\\n current_tile = str(x)+'-'+str(y)\\n urllib.request.urlretrieve(url, current_tile)\\n map_img.paste(Image.open(current_tile), (x*256, y*256))\\n os.remove(current_tile)\\n return map_img\",\n \"def _makeimap(self):\\n self.map_[\\\"source\\\"] = \\\"nasa\\\"\\n self.map_[\\\"instrument\\\"] = \\\"goes\\\"\\n self.map_[\\\"physobs\\\"] = \\\"irradiance\\\"\\n self.map_[\\\"provider\\\"] = \\\"sdac\\\"\",\n \"def maps(request):\\n #convert image locations to google maps parsable points\\n now = datetime.utcnow().replace(tzinfo=utc)\\n latlngs = search_utils.filter_date(search_utils.min_date, now)\\n points = [search_utils.to_map_point(image) for image in latlngs]\\n #load the search form sidebar\\n t = loader.get_template(\\\"wainz/search_form.html\\\")\\n ctx = Context({})\\n search_form = t.render(ctx)\\n\\n return render_to_response('wainz/maps.html', {\\\"latLngs\\\":points, \\\"search_form\\\":search_form, \\\"typeAheadTags\\\":Tag.objects.all()}, context_instance = RequestContext(request))\",\n \"def start_google_map_header(outfile: TextIO) -> None:\\n outfile.write(\\\" <script type=\\\\\\\"text/javascript\\\\\\\"\\\\n\\\")\\n outfile.write(\\\" src=\\\\\\\"https://maps.googleapis.com/maps/api/js?\\\"\\n \\\"key=AIzaSyAaITaFdh_own-ULkURNKtyeh2ZR_cpR74&sensor=false\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" </script>\\\\n\\\")\\n outfile.write(\\\" <script type=\\\\\\\"text/javascript\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" function initialize() {\\\\n\\\")\\n outfile.write(\\\" var mapOptions = {\\\\n\\\")\\n outfile.write(\\\" center: new google.maps.LatLng(0,0),\\\\n\\\")\\n outfile.write(\\\" zoom: 1,\\\\n\\\")\\n outfile.write(\\\" disableDefaultUI: true,\\\\n\\\")\\n outfile.write(\\\" panControl: false,\\\\n\\\")\\n outfile.write(\\\" zoomControl: true,\\\\n\\\")\\n outfile.write(\\\" mapTypeControl: true,\\\\n\\\")\\n outfile.write(\\\" scaleControl: false,\\\\n\\\")\\n outfile.write(\\\" streetViewControl: false,\\\\n\\\")\\n outfile.write(\\\" overviewMapControl: false,\\\\n\\\")\\n outfile.write(\\\" mapTypeId: google.maps.MapTypeId.TERRAIN\\\\n\\\")\\n outfile.write(\\\" };\\\\n\\\")\",\n \"def warp(self):\\n if not self.url or not self.sourceSRS:\\n return\\n self.map = mapscript.mapObj()\\n self.map.setSize(int(self.url.getArgument(\\\"width\\\")),int(self.url.getArgument(\\\"height\\\")))\\n (minx,miny,maxx,maxy) = map(lambda x: float(x), self.url.getArgument(\\\"bbox\\\").split(\\\",\\\"))\\n self.map.extent = mapscript.rectObj(minx,miny,maxx,maxy)\\n self.map.web.imagepath=tempfile.mkdtemp()\\n self.map.setProjection(self.targetSRS.__str__())\\n self.layer = mapscript.layerObj(self.map)\\n self.layer.type = mapscript.MS_LAYER_RASTER\\n self.layer.connection = self.url.getConnection()\\n self.layer.status = mapscript.MS_DEFAULT\\n self.layer.setConnectionType(mapscript.MS_WMS,None)\\n self.layer.setMetaData(\\\"wms_srs\\\",self.sourceSRS.__str__())\\n self.layer.setMetaData(\\\"wms_name\\\", self.url.getArgument(\\\"layers\\\"))\\n self.layer.setMetaData(\\\"wms_server_version\\\",self.url.getArgument(\\\"version\\\"))\\n\\n # WMS 1.3.0 is not supported by MapServer < 6.0 \\n # http://trac.osgeo.org/mapserver/ticket/3039\\n if self.url.getArgument(\\\"version\\\") == \\\"1.3.0\\\":\\n self.layer.setMetaData(\\\"wms_server_version\\\",\\\"1.1.1\\\")\\n \\n if self.sourceSRS.authority == \\\"CRS\\\" and self.sourceSRS.code == \\\"84\\\":\\n self.layer.setMetaData(\\\"wms_srs\\\",\\\"EPSG:4326\\\")\\n \\n\\n self.layer.setMetaData(\\\"wms_exceptions_format\\\",self.url.getArgument(\\\"exceptions\\\"))\\n self.layer.setMetaData(\\\"wms_formatlist\\\",self.url.getArgument(\\\"format\\\"))\\n self.layer.setMetaData(\\\"wms_style\\\",self.url.getArgument(\\\"style\\\"))\\n self.layer.setMetaData(\\\"wms_transparent\\\",self.url.getArgument(\\\"transparent\\\"))\\n self.layer.setProjection(self.sourceSRS.__str__())\\n self.layer.debug = 5\\n\\n if self.url.getArgument(\\\"format\\\") == \\\"image/png\\\":\\n self.map.outputformat.imagemode = mapscript.MS_IMAGEMODE_RGBA\\n if self.url.getArgument(\\\"format\\\") == \\\"image/jpg\\\":\\n self.layer.setMetaData(\\\"wms_formatlist\\\",\\\"image/jpeg\\\")\\n self.map.selectOutputFormat(\\\"image/jpeg\\\")\\n else:\\n self.map.selectOutputFormat(self.url.getArgument(\\\"format\\\"))\\n self.map.outputformat.transparent= 1\\n\\n try:\\n # draw the map\\n #self.map.save(\\\"/tmp/pokus2.map\\\")\\n image = self.map.draw()\\n if image:\\n return image\\n except :\\n\\n # something failed during the layer drawing. try to print the\\n # error to stderr as well as generate new image with the error\\n # message\\n exc_type, exc_value, exc_traceback = sys.exc_info()\\n traceback.print_exc(file=sys.stderr)\\n traceback.print_tb(exc_traceback, limit=1, file=sys.stderr)\\n\\n self.map.removeLayer(0)\\n self.map.setFontSet(os.path.join(os.path.abspath(os.path.dirname(__file__)),\\\"fonts.txt\\\"))\\n self.map.outputformat.transparent= 0\\n\\n self.layer = mapscript.layerObj(self.map)\\n self.layer.type = mapscript.MS_LAYER_ANNOTATION\\n #self.layer.transform = mapscript.MS_OFF\\n\\n line = mapscript.lineObj()\\n line.add(mapscript.pointObj(minx+(maxx-minx)/2.,miny+(maxy-miny)/2.))\\n feature = mapscript.shapeObj()\\n feature.add(line)\\n self.layer.addFeature(feature)\\n self.layer.labelcache = mapscript.MS_TRUE\\n \\n\\n classobj = mapscript.classObj(self.layer)\\n text = \\\"\\\"\\n \\n ## try to guess, where the problem is\\n for i in textwrap.wrap(str(exc_value),70):\\n text += i+\\\"\\\\n\\\"\\n classobj.setText(text)\\n\\n classobj.label.font = \\\"sans\\\"\\n classobj.label.type = mapscript.MS_TRUETYPE\\n classobj.label.antialias = mapscript.MS_FALSE\\n classobj.label.size = 12\\n classobj.label.position = mapscript.MS_CC\\n #classobj.label.partials = mapscript.MS_FALSE\\n classobj.label.force = mapscript.MS_TRUE\\n\\n\\n self.layer.status = mapscript.MS_ON\\n #self.map.save(\\\"/tmp/pokus3.map\\\")\\n image = self.map.draw()\\n return image\",\n \"def create_url(page_num, start_time, end_time, search_term):\\r\\n \\\"\\\"\\\"timestamp format: \\\\d\\\\d\\\\d\\\\d.\\\\d\\\\d.\\\\d\\\\d\\\"\\\"\\\" #2020.01.01 #新增 確診\\r\\n base=\\\"https://www.cdc.gov.tw/Bulletin/List/MmgtpeidAR5Ooai4-fgHzQ\\\"\\r\\n url = base + \\\"?page=\\\" + str(page_num) + \\\"&startTime=\\\" + str(start_time) + \\\"&endTime=\\\" + str(end_time) + \\\"&keyword=\\\" + str(search_term)\\r\\n return url\",\n \"def generate_openlayers(self):\\n\\n args = {}\\n args['title'] = self.options.title\\n args['bingkey'] = self.options.bingkey\\n args['south'], args['west'], args['north'], args['east'] = self.swne\\n args['minzoom'] = self.tminz\\n args['maxzoom'] = self.tmaxz\\n args['tilesize'] = self.tilesize\\n args['tileformat'] = self.tileext\\n args['publishurl'] = self.options.url\\n args['copyright'] = self.options.copyright\\n if self.options.tmscompatible:\\n args['tmsoffset'] = \\\"-1\\\"\\n else:\\n args['tmsoffset'] = \\\"\\\"\\n if self.options.profile == 'raster':\\n args['rasterzoomlevels'] = self.tmaxz+1\\n args['rastermaxresolution'] = 2**(self.nativezoom) * self.out_gt[1]\\n\\n s = r\\\"\\\"\\\"<!DOCTYPE html PUBLIC \\\"-//W3C//DTD XHTML 1.0 Strict//EN\\\" \\\"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd\\\">\\n <html xmlns=\\\"http://www.w3.org/1999/xhtml\\\"\\n <head>\\n <title>%(title)s</title>\\n <meta http-equiv='imagetoolbar' content='no'/>\\n <style type=\\\"text/css\\\"> v\\\\:* {behavior:url(#default#VML);}\\n html, body { overflow: hidden; padding: 0; height: 100%%; width: 100%%; font-family: 'Lucida Grande',Geneva,Arial,Verdana,sans-serif; }\\n body { margin: 10px; background: #fff; }\\n h1 { margin: 0; padding: 6px; border:0; font-size: 20pt; }\\n #header { height: 43px; padding: 0; background-color: #eee; border: 1px solid #888; }\\n #subheader { height: 12px; text-align: right; font-size: 10px; color: #555;}\\n #map { height: 95%%; border: 1px solid #888; }\\n .olImageLoadError { display: none; }\\n .olControlLayerSwitcher .layersDiv { border-radius: 10px 0 0 10px; }\\n </style>\\\"\\\"\\\" % args # noqa\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n <script src='http://maps.google.com/maps/api/js?sensor=false&v=3.7'></script>\\n \\\"\\\"\\\" % args\\n\\n s += \\\"\\\"\\\"\\n <script src=\\\"http://www.openlayers.org/api/2.12/OpenLayers.js\\\"></script>\\n <script>\\n var map;\\n var mapBounds = new OpenLayers.Bounds( %(west)s, %(south)s, %(east)s, %(north)s);\\n var mapMinZoom = %(minzoom)s;\\n var mapMaxZoom = %(maxzoom)s;\\n var emptyTileURL = \\\"http://www.maptiler.org/img/none.png\\\";\\n OpenLayers.IMAGE_RELOAD_ATTEMPTS = 3;\\n\\n function init(){\\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n projection: \\\"EPSG:3857\\\",\\n displayProjection: new OpenLayers.Projection(\\\"EPSG:4326\\\"),\\n numZoomLevels: 20\\n };\\n map = new OpenLayers.Map(options);\\n\\n // Create Google Mercator layers\\n var gmap = new OpenLayers.Layer.Google(\\\"Google Streets\\\",\\n {\\n type: google.maps.MapTypeId.ROADMAP,\\n sphericalMercator: true\\n });\\n var gsat = new OpenLayers.Layer.Google(\\\"Google Satellite\\\",\\n {\\n type: google.maps.MapTypeId.SATELLITE,\\n sphericalMercator: true\\n });\\n var ghyb = new OpenLayers.Layer.Google(\\\"Google Hybrid\\\",\\n {\\n type: google.maps.MapTypeId.HYBRID,\\n sphericalMercator: true\\n });\\n var gter = new OpenLayers.Layer.Google(\\\"Google Terrain\\\",\\n {\\n type: google.maps.MapTypeId.TERRAIN,\\n sphericalMercator: true\\n });\\n\\n // Create Bing layers\\n var broad = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Roads\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"Road\\\",\\n sphericalMercator: true\\n });\\n var baer = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Aerial\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"Aerial\\\",\\n sphericalMercator: true\\n });\\n var bhyb = new OpenLayers.Layer.Bing({\\n name: \\\"Bing Hybrid\\\",\\n key: \\\"%(bingkey)s\\\",\\n type: \\\"AerialWithLabels\\\",\\n sphericalMercator: true\\n });\\n\\n // Create OSM layer\\n var osm = new OpenLayers.Layer.OSM(\\\"OpenStreetMap\\\");\\n\\n \\\"\\\"\\\" % args # noqa\\n\\t\\t \\n if self.options.xyz:\\n s += \\\"\\\"\\\"\\t\\t \\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.XYZ(\\\"XYZ Overlay\\\",\\n \\\"${z}/${x}/${y}.png\\\", {\\n transitionEffect: 'resize',\\n isBaseLayer: false\\n });\\n\\t\\t\\t\\t \\n\\t\\t \\\"\\\"\\\" % args # noqa\\n else:\\n s += \\\"\\\"\\\"\\t\\t \\n // create TMS Overlay layer\\n var tmsoverlay = new OpenLayers.Layer.TMS(\\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n isBaseLayer: false,\\n getURL: getURL\\n });\\n\\t\\t\\t\\t \\n\\t\\t \\\"\\\"\\\" % args # noqa\\t\\t \\n\\t\\t \\n s += \\\"\\\"\\\" \\n if (OpenLayers.Util.alphaHack() == false) {\\n tmsoverlay.setOpacity(0.7);\\n }\\n\\n map.addLayers([gmap, gsat, ghyb, gter,\\n broad, baer, bhyb,\\n osm, tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent(mapBounds.transform(map.displayProjection, map.projection));\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n projection: \\\"EPSG:4326\\\"\\n };\\n map = new OpenLayers.Map(options);\\n\\n var wms = new OpenLayers.Layer.WMS(\\\"VMap0\\\",\\n \\\"http://tilecache.osgeo.org/wms-c/Basic.py?\\\",\\n {\\n layers: 'basic',\\n format: 'image/png'\\n }\\n );\\n var tmsoverlay = new OpenLayers.Layer.TMS(\\\"TMS Overlay\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n isBaseLayer: false,\\n getURL: getURL\\n });\\n if (OpenLayers.Util.alphaHack() == false) {\\n tmsoverlay.setOpacity(0.7);\\n }\\n\\n map.addLayers([wms,tmsoverlay]);\\n\\n var switcherControl = new OpenLayers.Control.LayerSwitcher();\\n map.addControl(switcherControl);\\n switcherControl.maximizeControl();\\n\\n map.zoomToExtent(mapBounds);\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'raster':\\n s += \\\"\\\"\\\"\\n var options = {\\n div: \\\"map\\\",\\n controls: [],\\n maxExtent: new OpenLayers.Bounds(%(west)s, %(south)s, %(east)s, %(north)s),\\n maxResolution: %(rastermaxresolution)f,\\n numZoomLevels: %(rasterzoomlevels)d\\n };\\n map = new OpenLayers.Map(options);\\n\\n var layer = new OpenLayers.Layer.TMS(\\\"TMS Layer\\\", \\\"\\\",\\n {\\n serviceVersion: '.',\\n layername: '.',\\n alpha: true,\\n type: '%(tileformat)s',\\n getURL: getURL\\n });\\n\\n map.addLayer(layer);\\n map.zoomToExtent(mapBounds);\\n \\\"\\\"\\\" % args # noqa\\n\\n s += \\\"\\\"\\\"\\n map.addControls([new OpenLayers.Control.PanZoomBar(),\\n new OpenLayers.Control.Navigation(),\\n new OpenLayers.Control.MousePosition(),\\n new OpenLayers.Control.ArgParser(),\\n new OpenLayers.Control.Attribution()]);\\n }\\n \\\"\\\"\\\" % args\\n\\n if self.options.profile == 'mercator' and self.options.xyz is None:\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom();\\n if (this.map.baseLayer.CLASS_NAME === 'OpenLayers.Layer.Bing') {\\n z+=1;\\n }\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'geodetic':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom()%(tmsoffset)s;\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n elif self.options.profile == 'raster':\\n s += \\\"\\\"\\\"\\n function getURL(bounds) {\\n bounds = this.adjustBounds(bounds);\\n var res = this.getServerResolution();\\n var x = Math.round((bounds.left - this.tileOrigin.lon) / (res * this.tileSize.w));\\n var y = Math.round((bounds.bottom - this.tileOrigin.lat) / (res * this.tileSize.h));\\n var z = this.getServerZoom();\\n var path = this.serviceVersion + \\\"/\\\" + this.layername + \\\"/\\\" + z + \\\"/\\\" + x + \\\"/\\\" + y + \\\".\\\" + this.type;\\n var url = this.url;\\n if (OpenLayers.Util.isArray(url)) {\\n url = this.selectUrl(path, url);\\n }\\n if (mapBounds.intersectsBounds(bounds) && (z >= mapMinZoom) && (z <= mapMaxZoom)) {\\n return url + path;\\n } else {\\n return emptyTileURL;\\n }\\n }\\n \\\"\\\"\\\" % args # noqa\\n\\n s += \\\"\\\"\\\"\\n function getWindowHeight() {\\n if (self.innerHeight) return self.innerHeight;\\n if (document.documentElement && document.documentElement.clientHeight)\\n return document.documentElement.clientHeight;\\n if (document.body) return document.body.clientHeight;\\n return 0;\\n }\\n\\n function getWindowWidth() {\\n if (self.innerWidth) return self.innerWidth;\\n if (document.documentElement && document.documentElement.clientWidth)\\n return document.documentElement.clientWidth;\\n if (document.body) return document.body.clientWidth;\\n return 0;\\n }\\n\\n function resize() {\\n var map = document.getElementById(\\\"map\\\");\\n var header = document.getElementById(\\\"header\\\");\\n var subheader = document.getElementById(\\\"subheader\\\");\\n map.style.height = (getWindowHeight()-80) + \\\"px\\\";\\n map.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n header.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n subheader.style.width = (getWindowWidth()-20) + \\\"px\\\";\\n if (map.updateSize) { map.updateSize(); };\\n }\\n\\n onresize=function(){ resize(); };\\n\\n </script>\\n </head>\\n <body onload=\\\"init()\\\">\\n <div id=\\\"header\\\"><h1>%(title)s</h1></div>\\n <div id=\\\"subheader\\\">Generated by <a href=\\\"http://www.klokan.cz/projects/gdal2tiles/\\\">GDAL2Tiles</a>, Copyright © 2008 <a href=\\\"http://www.klokan.cz/\\\">Klokan Petr Pridal</a>, <a href=\\\"http://www.gdal.org/\\\">GDAL</a> & <a href=\\\"http://www.osgeo.org/\\\">OSGeo</a> <a href=\\\"http://code.google.com/soc/\\\">GSoC</a>\\n <!-- PLEASE, LET THIS NOTE ABOUT AUTHOR AND PROJECT SOMEWHERE ON YOUR WEBSITE, OR AT LEAST IN THE COMMENT IN HTML. THANK YOU -->\\n </div>\\n <div id=\\\"map\\\"></div>\\n <script type=\\\"text/javascript\\\" >resize()</script>\\n </body>\\n </html>\\\"\\\"\\\" % args # noqa\\n\\n return s\",\n \"def test_url_helper_coordinates():\\n urlh = URLHelper()\\n args = []\\n kwargs = {\\\"coordinates\\\": \\\"210.80242917 54.348753\\\"}\\n url = urlh.build_url(*args, **kwargs)\\n assert url == \\\"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/ra=210.802429/dec=54.348753\\\"\",\n \"def create_url(_origin_details, travel_start_date, travel_start_time, destination_list):\\n prefix = 'https://timetable.search.ch/api/route.json?one_to_many=1'\\n\\n origin_body = f'&from={_origin_details}&date={travel_start_date}&time={travel_start_time}'\\n\\n # Build iteratively with necessary syntax between destinations\\n destination_body = ''\\n for i, dest in enumerate(destination_list):\\n destination_body = f'{destination_body}&to[{i}]={dest}'\\n\\n return f'{prefix}{origin_body}{destination_body}'\",\n \"def generate_lookat_kml_block(self, lng, lat, viewrange):\\n return \\\"\\\"\\\"\\n <LookAt>\\n <longitude>%.14f</longitude>\\n <latitude>%.14f</latitude>\\n <altitude>0</altitude>\\n <range>%.f</range>\\n <tilt>0</tilt>\\n <heading>0</heading>\\n </LookAt>\\n\\\"\\\"\\\" % (lng, lat, viewrange)\",\n \"def generateMarkers(self, *args, **kwargs): \\n return 'var PloneMapMarkers = [' + \\\\\\n ''.join([\\\"{'type': '%s','options': { 'position': new google.maps.LatLng( %s, %s ), 'title' : '%s', 'title_' : '%s' }},\\\" \\n % (object.markerIcon, object.latitude, object.longitude, object.Title(), object.getId()) \\n for object in self.context.objectValues() \\n if hasattr(object, 'latitude') and len(object.latitude) > 0 ])[:-1] \\\\\\n + '];'\",\n \"def decorateMap(mapObj, startxy):\\n\\n startx, starty = startxy # Syntactic sugar\\n\\n # Copy the map object so we don't modify the original passed\\n # TODO: Copy!\\n mapObjCopy = mapObj[:]\\n\\n # Remove the non-wall characters from the map data\\n for x in range(len(mapObjCopy)):\\n for y in range(len(mapObjCopy[0])):\\n if mapObjCopy[x][y] in ('$', '.', '@', '+', '*'):\\n mapObjCopy[x][y] = ' '\\n\\n # Flood fill to determine inside/outside floor tiles.\\n floodFill(mapObjCopy, startx, starty, ' ', 'o')\\n\\n # Convert the adj8oined walls into corner tiles.\\n for x in range(len(mapObjCopy)):\\n for y in range(len(mapObjCopy[0])):\\n\\n if mapObjCopy[x][y] == '#':\\n if (isWall(mapObjCopy, x, y-1) and isWall(mapObjCopy, x+1, y)) or \\\\\\n (isWall(mapObjCopy, x+1, y) and isWall(mapObjCopy, x, y+1)) or \\\\\\n (isWall(mapObjCopy, x, y+1) and isWall(mapObjCopy, x-1, y)) or \\\\\\n (isWall(mapObjCopy, x-1, y) and isWall(mapObjCopy, x, y-1)):\\n mapObjCopy[x][y] = 'x'\\n\\n elif mapObjCopy[x][y] == ' ' and random.randint(0, 99) < OUTSIDE_DECORATION_PCT:\\n mapObjCopy[x][y] = random.choice(list(OUTSIDEDECOMAPPING.keys()))\\n\\n return mapObjCopy\",\n \"def generate_link_kml(self, d):\\n return \\\"\\\"\\\"\\\\\\n <NetworkLink>\\n <name>%(image_filename)s</name>\\n <Region>\\n <Lod>\\n <minLodPixels>%(minlodpixels)d</minLodPixels>\\n <maxLodPixels>-1</maxLodPixels>\\n </Lod>\\n <LatLonAltBox>\\n <north>%(north).14f</north>\\n <south>%(south).14f</south>\\n <east>%(east).14f</east>\\n <west>%(west).14f</west>\\n </LatLonAltBox>\\n </Region>\\n <Link>\\n <href>%(link_url)s</href>\\n <viewRefreshMode>onRegion</viewRefreshMode>\\n </Link>\\n </NetworkLink>\\\"\\\"\\\" % d\",\n \"def _show_map(service_code=None, reverse=None, atco_code=None, coords=None):\\n if atco_code is not None:\\n stop = models.StopPoint.query.get(atco_code.upper())\\n if stop is None:\\n raise NotFound(\\n Markup(\\\"Stop with code <strong>{}</strong> does not exist.\\\")\\n .format(atco_code)\\n )\\n else:\\n stop = None\\n\\n if service_code is not None:\\n sv = (\\n models.Service.query\\n .options(db.joinedload(models.Service.patterns))\\n .filter(models.Service.code == service_code)\\n .one_or_none()\\n )\\n if sv is None:\\n raise NotFound(\\n Markup(\\\"Service <strong>{}</strong> does not exist.\\\")\\n .format(service_code)\\n )\\n is_reverse, _ = sv.has_mirror(reverse)\\n else:\\n sv = None\\n is_reverse = None\\n\\n # TODO: Add redirect for incorrect capitalisation, etc\\n\\n # Quick check to ensure coordinates are within range of Great Britain\\n if coords is not None and location.check_bounds(coords[0], coords[1]):\\n latitude, longitude, zoom = coords\\n else:\\n latitude, longitude, zoom = None, None, None\\n\\n return render_template(\\\"map.html\\\", latitude=latitude, longitude=longitude,\\n zoom=zoom, stop=stop, service=sv, reverse=is_reverse)\",\n \"def write_location_page(outfile: TextIO, do_print: bool, loc: TMB_Classes.LocationClass, point_locations: dict,\\n location_species: dict, location_bi_names: dict, location_sp_names: dict,\\n location_direct_refs: dict, location_cited_refs: dict, references: list,\\n locations_range_species: dict, location_keys: Optional[dict]) -> None:\\n\\n def format_latlon(lat: float, lon: float) -> str:\\n \\\"\\\"\\\"\\n subfunction to format a lat,lon pair for printing\\n \\\"\\\"\\\"\\n if lat < 0:\\n latdir = \\\"S\\\"\\n else:\\n latdir = \\\"N\\\"\\n if lon < 0:\\n londir = \\\"W\\\"\\n else:\\n londir = \\\"E\\\"\\n return \\\"{:1.6f}°{}, {:1.6f}°{}\\\".format(abs(lat), latdir, abs(lon), londir)\\n\\n # main function code\\n if do_print:\\n start_page_division(outfile, \\\"base_page\\\")\\n else:\\n common_header_part1(outfile, loc.trimmed_name, indexpath=\\\"../\\\")\\n if not loc.unknown:\\n start_google_map_header(outfile)\\n write_google_map_point_header(outfile, \\\"location_\\\" + place_to_filename(loc.name))\\n end_google_map_header(outfile)\\n common_header_part2(outfile, indexpath=\\\"../\\\", include_map=True)\\n\\n outfile.write(\\\" <header id=\\\\\\\"\\\" + place_to_filename(loc.name) + \\\".html\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <h1 class=\\\\\\\"nobookmark\\\\\\\">\\\" + loc.trimmed_name + \\\"</h1>\\\\n\\\")\\n if not do_print:\\n outfile.write(\\\" <nav>\\\\n\\\")\\n outfile.write(\\\" <ul>\\\\n\\\")\\n outfile.write(\\\" <li><a href=\\\\\\\"index.html\\\\\\\">\\\" + fetch_fa_glyph(\\\"index\\\") + \\\"Location Index</a></li>\\\\n\\\")\\n outfile.write(\\\" </ul>\\\\n\\\")\\n outfile.write(\\\" </nav>\\\\n\\\")\\n outfile.write(\\\" </header>\\\\n\\\")\\n outfile.write(\\\" <dl>\\\\n\\\")\\n\\n if loc.n_alternates() > 0:\\n outfile.write(\\\" <dt>Also Known As</dt>\\\\n\\\")\\n outfile.write(\\\" <dd>\\\" + \\\", \\\".join(loc.alternates) + \\\"</dd>\\\\n\\\")\\n if loc.n_parents() > 0:\\n outfile.write(\\\" <dt>Included Within</dt>\\\\n\\\")\\n if loc.parent is not None:\\n p = point_locations[loc.parent]\\n dstr = create_location_link(p, p.trimmed_name, do_print)\\n else:\\n dstr = None\\n if loc.n_secondary_parents() > 0:\\n if dstr is None:\\n dlist = []\\n else:\\n dlist = [dstr]\\n for a in loc.secondary_parents:\\n p = point_locations[a]\\n dlist.append(create_location_link(p, p.trimmed_name, do_print))\\n dstr = \\\", \\\".join(dlist)\\n outfile.write(\\\" <dd>\\\" + dstr + \\\"</dd>\\\\n\\\")\\n if loc.unknown:\\n outfile.write(\\\" <dt>Location Could not be Identified</dt>\\\\n\\\")\\n if loc.notes is not None:\\n outfile.write(\\\" <dd>\\\" + loc.notes + \\\"</dd>\\\\n\\\")\\n else:\\n if loc.notes is not None:\\n outfile.write(\\\" <dt>Note</dt>\\\\n\\\")\\n outfile.write(\\\" <dd>\\\" + loc.notes + \\\"</dd>\\\\n\\\")\\n outfile.write(\\\" <dt>Approximate Coordinates</dt>\\\\n\\\")\\n outfile.write(\\\" <dd>\\\" + format_latlon(loc.latitude, loc.longitude) + \\\"</dd>\\\\n\\\")\\n outfile.write(\\\" <div class=\\\\\\\"map_section\\\\\\\">\\\\n\\\")\\n if do_print:\\n outfile.write(\\\" <figure>\\\\n\\\")\\n outfile.write(\\\" <img src=\\\\\\\"\\\" + TMP_MAP_PATH +\\n pointmap_name(\\\"location_\\\" + place_to_filename(loc.name)) + \\\".png\\\\\\\" alt=\\\\\\\"\\\" +\\n loc.trimmed_name + \\\"\\\\\\\" title=\\\\\\\"Map of \\\" + loc.trimmed_name + \\\"\\\\\\\" />\\\\n\\\")\\n outfile.write(\\\" </figure>\\\\n\\\")\\n else:\\n outfile.write(\\\" <div id=\\\\\\\"point_map_canvas\\\\\\\" class=\\\\\\\"sp_map\\\\\\\"></div>\\\\n\\\")\\n\\n outfile.write(\\\" <div class=\\\\\\\"map_download\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" The red marker indicates the coordinates used to represent this location, \\\"\\n \\\"yellow markers all other locations contained within this location. Purple markers indicate \\\"\\n \\\"fossil-only locations or sub-locations.\\\\n\\\")\\n outfile.write(\\\" </div>\\\\n\\\")\\n\\n outfile.write(\\\" </div>\\\\n\\\")\\n outfile.write(\\\" </dl>\\\\n\\\")\\n all_species = set()\\n all_species |= location_species[loc.name]\\n all_bi_names = set()\\n all_bi_names |= location_bi_names[loc.name]\\n all_sp_names = set()\\n all_sp_names |= location_sp_names[loc.name]\\n all_refs = set()\\n all_refs |= location_direct_refs[loc.name]\\n all_refs |= location_cited_refs[loc.name]\\n if loc.n_direct_children() > 0:\\n outfile.write(\\\" <section class=\\\\\\\"spsection\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <h3 class=\\\\\\\"nobookmark\\\\\\\">Includes Subareas</h3>\\\\n\\\")\\n outfile.write(\\\" <ul class=\\\\\\\"locpagelist\\\\\\\">\\\\n\\\")\\n for c in loc.direct_children():\\n outfile.write(\\\" <li>\\\" + create_location_link(c, c.trimmed_name, do_print) + \\\"</li>\\\\n\\\")\\n all_species |= fetch_child_data(c, location_species)\\n all_bi_names |= fetch_child_data(c, location_bi_names)\\n all_sp_names |= fetch_child_data(c, location_sp_names)\\n all_refs |= fetch_child_ref_data(c, location_direct_refs)\\n all_refs |= fetch_child_ref_data(c, location_cited_refs)\\n outfile.write(\\\" </ul>\\\\n\\\")\\n outfile.write(\\\" </section>\\\\n\\\")\\n\\n # add species\\n range_species = set(find_species_by_name(s) for s in locations_range_species[loc])\\n range_species -= all_species\\n all_species |= range_species\\n\\n is_error = True\\n print_star = False\\n print_double = False\\n outfile.write(\\\" <section class=\\\\\\\"spsection\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <h3 class=\\\\\\\"nobookmark\\\\\\\">Currently Recognized Species</h3>\\\\n\\\")\\n if len(all_species) > 0:\\n is_error = False\\n # outfile.write(\\\" <section class=\\\\\\\"spsection\\\\\\\">\\\\n\\\")\\n # outfile.write(\\\" <h3 class=\\\\\\\"nobookmark\\\\\\\">Currently Recognized Species</h3>\\\\n\\\")\\n outfile.write(\\\" <ul class=\\\\\\\"locpagelist\\\\\\\">\\\\n\\\")\\n for s in sorted(list(all_species)):\\n if s in location_species[loc.name]:\\n suffix = \\\"\\\"\\n elif s in range_species:\\n suffix = DOUBLEDAGGER\\n print_double = True\\n else:\\n suffix = STAR\\n print_star = True\\n outfile.write(\\\" <li>\\\" +\\n create_species_link(s.genus, s.species, do_print, status=s.status, path=\\\"../\\\") +\\n suffix + \\\"</li>\\\\n\\\")\\n outfile.write(\\\" </ul>\\\\n\\\")\\n else:\\n outfile.write(\\\" <p>None</p>\\\\n\\\")\\n outfile.write(\\\" </section>\\\\n\\\")\\n\\n if len(all_bi_names) > 0:\\n is_error = False\\n outfile.write(\\\" <section class=\\\\\\\"spsection\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <h3 class=\\\\\\\"nobookmark\\\\\\\">Names Which Have Been Used for This Area</h3>\\\\n\\\")\\n outfile.write(\\\" <ul class=\\\\\\\"locpagelist\\\\\\\">\\\\n\\\")\\n for s in sorted(list(all_bi_names)):\\n if s in location_bi_names[loc.name]:\\n suffix = \\\"\\\"\\n else:\\n suffix = STAR\\n print_star = True\\n outfile.write(\\\" <li><a href=\\\\\\\"\\\" + rel_link_prefix(do_print, \\\"../names/\\\") + name_to_filename(s) +\\n \\\".html\\\\\\\">\\\" + format_name_string(s) + \\\"</a>\\\" + suffix + \\\"</li>\\\\n\\\")\\n outfile.write(\\\" </ul>\\\\n\\\")\\n outfile.write(\\\" </section>\\\\n\\\")\\n\\n if len(all_sp_names) > 0:\\n is_error = False\\n outfile.write(\\\" <section class=\\\\\\\"spsection\\\\\\\">\\\\n\\\")\\n outfile.write(\\\" <h3 class=\\\\\\\"nobookmark\\\\\\\">Specific Names Which Have Been Used for This Area</h3>\\\\n\\\")\\n outfile.write(\\\" <ul class=\\\\\\\"locpagelist\\\\\\\">\\\\n\\\")\\n for s in sorted(list(all_sp_names)):\\n if s in location_sp_names[loc.name]:\\n suffix = \\\"\\\"\\n else:\\n suffix = STAR\\n print_star = True\\n outfile.write(\\\" <li><a href=\\\\\\\"\\\" + rel_link_prefix(do_print, \\\"../names/\\\") + \\\"sn_\\\" + s.name +\\n \\\".html\\\\\\\">\\\" + format_name_string(s.name) + \\\"</a>\\\" + suffix + \\\"</li>\\\\n\\\")\\n outfile.write(\\\" </ul>\\\\n\\\")\\n outfile.write(\\\" </section>\\\\n\\\")\\n\\n # the following is to identify locations which may no longer used in the DB and can be removed\\n # if is_error:\\n # report_error(\\\"Phantom Location: \\\" + loc.name)\\n\\n write_annotated_reference_list(outfile, do_print, references, all_refs, location_direct_refs[loc.name],\\n location_cited_refs[loc.name], \\\"../\\\")\\n\\n if len(location_direct_refs[loc.name]) != len(location_cited_refs[loc.name]):\\n key_str = \\\"Entries marked with \\\" + DAGGER + \\\" represent indirect references to location through citation. \\\"\\n else:\\n key_str = \\\"\\\"\\n if print_star:\\n key_str += \\\"Entries marked with \\\" + STAR + \\\" are inferred from subareas. \\\"\\n if print_double:\\n key_str += \\\"Entries marked with \\\" + DOUBLEDAGGER + \\\" represent potential inhabitants inferred from \\\" \\\\\\n \\\"species ranges.\\\"\\n if key_str != \\\"\\\":\\n outfile.write(\\\" <p>\\\" + key_str.strip() + \\\"</p>\\\\n\\\")\\n\\n if do_print:\\n end_page_division(outfile)\\n else:\\n common_html_footer(outfile)\\n\\n # output place specific taxonomic key\\n if (location_keys is not None) and (len(all_species) > 0):\\n if do_print:\\n write_taxonomic_key(outfile, do_print, location_keys[frozenset(all_species)], loc)\\n else:\\n with open(WEBOUT_PATH + \\\"locations/keys/\\\" + place_to_filename(loc.name) + \\\"_taxkey.html\\\", \\\"w\\\",\\n encoding=\\\"utf-8\\\") as suboutfile:\\n write_taxonomic_key(suboutfile, do_print, location_keys[frozenset(all_species)], loc)\\n\\n # write out children pages (primary children only)\\n if loc.n_children() > 0:\\n for c in loc.children:\\n if do_print:\\n write_location_page(outfile, do_print, c, point_locations, location_species, location_bi_names,\\n location_sp_names, location_direct_refs, location_cited_refs, references,\\n locations_range_species, location_keys)\\n else:\\n with open(WEBOUT_PATH + \\\"locations/\\\" + place_to_filename(c.name) + \\\".html\\\", \\\"w\\\",\\n encoding=\\\"utf-8\\\") as suboutfile:\\n write_location_page(suboutfile, do_print, c, point_locations, location_species, location_bi_names,\\n location_sp_names, location_direct_refs, location_cited_refs, references,\\n locations_range_species, location_keys)\",\n \"def create_url(keyword, hits_limit, start_record, api_key):\\n keyword = requests.utils.quote(keyword)\\n url_base = (\\\"http://kulturarvsdata.se/ksamsok/api?x-api={api_key}\\\"\\n \\\"&method=search&hitsPerPage={hits_limit}\\\"\\n \\\"&startRecord={start_record}\\\"\\n \\\"&query=serviceOrganization=RA%C3%84%20\\\"\\n \\\"and%20serviceName=KMB%20\\\"\\n \\\"and%20itemType=foto%20and%20mediaLicense=*%20\\\"\\n \\\"and%20text={keyword}\\\")\\n return url_base.format(api_key=api_key,\\n hits_limit=hits_limit,\\n start_record=start_record,\\n keyword=keyword)\",\n \"def build_map(chunk_start, result, total_chunks, start_id, end_id):\\n size = len(chunk_start)\\n for i in prange(size):\\n beg = chunk_start[i]\\n end = chunk_start[i + 1] if i < size - 1 else total_chunks\\n if start_id < end and beg < end_id: # [beg, end) intersect [start_id, end_id)\\n result[max(beg - start_id, 0) : (end - start_id), 0] = beg\\n result[max(beg - start_id, 0) : (end - start_id), 1] = end\",\n \"def format_coordinates(max_lat, max_lng, min_lat, min_lng, centre_lat, centre_lng):\\n centre_coordinate = str(centre_lat) + ', ' + str(centre_lng)\\n bottom_left_coordinate = str(min_lat) + ', ' + str(min_lng)\\n top_right_coordinate = str(max_lat) + ', ' + str(max_lng)\\n\\n return centre_coordinate + '&bounds=' + bottom_left_coordinate + '|' + top_right_coordinate\",\n \"def generate_map(self):\\n\\n # Create main streets first\\n self.create_main_streets()\\n\\n # Then create the commercial buildings in the center of town\\n self.create_commercial_center()\\n\\n # Then create the neighborhoods that populate the rest of the city\\n while(self.create_neighborhood()):\\n pass\\n\\n # Clean up any invalid buildings that were created\\n self.delete_inaccessible_buildings()\",\n \"def build_request_url(symbol, start_date, end_date):\\n pass\",\n \"def maps():\\n\\n if request.env.request_method == \\\"GET\\\":\\n # This is a request to read the config of a saved map\\n\\n # Which map are we updating?\\n id = request.args(0)\\n if not id:\\n raise HTTP(501)\\n\\n # Read the WMC record\\n record = db(db.gis_wmc.id == id).select(limitby=(0, 1)).first()\\n # & linked records\\n #projection = db(db.gis_projection.id == record.projection).select(limitby=(0, 1)).first()\\n\\n # Put details into the correct structure\\n output = dict()\\n output[\\\"map\\\"] = dict()\\n map = output[\\\"map\\\"]\\n map[\\\"center\\\"] = [record.lat, record.lon]\\n map[\\\"zoom\\\"] = record.zoom\\n # @ToDo: Read Projection (we generally use 900913 & no way to edit this yet)\\n map[\\\"projection\\\"] = \\\"EPSG:900913\\\"\\n map[\\\"units\\\"] = \\\"m\\\"\\n map[\\\"maxResolution\\\"] = 156543.0339\\n map[\\\"maxExtent\\\"] = [ -20037508.34, -20037508.34, 20037508.34, 20037508.34 ]\\n # @ToDo: Read Layers\\n map[\\\"layers\\\"] = []\\n #map[\\\"layers\\\"].append(dict(source=\\\"google\\\", title=\\\"Google Terrain\\\", name=\\\"TERRAIN\\\", group=\\\"background\\\"))\\n #map[\\\"layers\\\"].append(dict(source=\\\"ol\\\", group=\\\"background\\\", fixed=True, type=\\\"OpenLayers.Layer\\\", args=[ \\\"None\\\", {\\\"visibility\\\":False} ]))\\n for _layer in record.layer_id:\\n layer = db(db.gis_wmc_layer.id == _layer).select(limitby=(0, 1)).first()\\n if layer.type_ == \\\"OpenLayers.Layer\\\":\\n # Add args\\n map[\\\"layers\\\"].append(dict(source=layer.source, title=layer.title, name=layer.name, group=layer.group_, type=layer.type_, format=layer.img_format, visibility=layer.visibility, transparent=layer.transparent, opacity=layer.opacity, fixed=layer.fixed, args=[ \\\"None\\\", {\\\"visibility\\\":False} ]))\\n else:\\n map[\\\"layers\\\"].append(dict(source=layer.source, title=layer.title, name=layer.name, group=layer.group_, type=layer.type_, format=layer.img_format, visibility=layer.visibility, transparent=layer.transparent, opacity=layer.opacity, fixed=layer.fixed))\\n\\n # @ToDo: Read Metadata (no way of editing this yet)\\n\\n # Encode as JSON\\n output = json.dumps(output)\\n\\n # Output to browser\\n response.headers[\\\"Content-Type\\\"] = \\\"application/json\\\"\\n return output\\n\\n elif request.env.request_method == \\\"POST\\\":\\n # This is a request to save/publish a new map\\n\\n # Get the data from the POST\\n source = request.body.read()\\n if isinstance(source, basestring):\\n from StringIO import StringIO\\n source = StringIO(source)\\n\\n # Decode JSON\\n source = json.load(source)\\n # @ToDo: Projection (we generally use 900913 & no way to edit this yet)\\n lat = source[\\\"map\\\"][\\\"center\\\"][0]\\n lon = source[\\\"map\\\"][\\\"center\\\"][1]\\n zoom = source[\\\"map\\\"][\\\"zoom\\\"]\\n # Layers\\n layers = []\\n for layer in source[\\\"map\\\"][\\\"layers\\\"]:\\n try:\\n opacity = layer[\\\"opacity\\\"]\\n except:\\n opacity = None\\n try:\\n name = layer[\\\"name\\\"]\\n except:\\n name = None\\n _layer = db((db.gis_wmc_layer.source == layer[\\\"source\\\"]) &\\n (db.gis_wmc_layer.name == name) &\\n (db.gis_wmc_layer.visibility == layer[\\\"visibility\\\"]) &\\n (db.gis_wmc_layer.opacity == opacity)\\n ).select(db.gis_wmc_layer.id,\\n limitby=(0, 1)).first()\\n if _layer:\\n # This is an existing layer\\n layers.append(_layer.id)\\n else:\\n # This is a new layer\\n try:\\n type_ = layer[\\\"type\\\"]\\n except:\\n type_ = None\\n try:\\n group_ = layer[\\\"group\\\"]\\n except:\\n group_ = None\\n try:\\n fixed = layer[\\\"fixed\\\"]\\n except:\\n fixed = None\\n try:\\n format = layer[\\\"format\\\"]\\n except:\\n format = None\\n try:\\n transparent = layer[\\\"transparent\\\"]\\n except:\\n transparent = None\\n # Add a new record to the gis_wmc_layer table\\n _layer = db.gis_wmc_layer.insert(source=layer[\\\"source\\\"], name=name, visibility=layer[\\\"visibility\\\"], opacity=opacity, type_=type_, title=layer[\\\"title\\\"], group_=group_, fixed=fixed, transparent=transparent, img_format=format)\\n layers.append(_layer)\\n\\n # @ToDo: Metadata (no way of editing this yet)\\n\\n # Save a record in the WMC table\\n id = db.gis_wmc.insert(lat=lat, lon=lon, zoom=zoom, layer_id=layers)\\n\\n # Return the ID of the saved record for the Bookmark\\n output = json.dumps(dict(id=id))\\n return output\\n\\n elif request.env.request_method == \\\"PUT\\\":\\n # This is a request to save/publish an existing map\\n\\n # Which map are we updating?\\n id = request.args(0)\\n if not id:\\n raise HTTP(501)\\n\\n # Get the data from the PUT\\n source = request.body.read()\\n if isinstance(source, basestring):\\n from StringIO import StringIO\\n source = StringIO(source)\\n\\n # Decode JSON\\n source = json.load(source)\\n # @ToDo: Projection (unlikely to change)\\n lat = source[\\\"map\\\"][\\\"center\\\"][0]\\n lon = source[\\\"map\\\"][\\\"center\\\"][1]\\n zoom = source[\\\"map\\\"][\\\"zoom\\\"]\\n # Layers\\n layers = []\\n for layer in source[\\\"map\\\"][\\\"layers\\\"]:\\n try:\\n opacity = layer[\\\"opacity\\\"]\\n except:\\n opacity = None\\n try:\\n name = layer[\\\"name\\\"]\\n except:\\n name = None\\n _layer = db((db.gis_wmc_layer.source == layer[\\\"source\\\"]) &\\n (db.gis_wmc_layer.name == name) &\\n (db.gis_wmc_layer.visibility == layer[\\\"visibility\\\"]) &\\n (db.gis_wmc_layer.opacity == opacity)\\n ).select(db.gis_wmc_layer.id,\\n limitby=(0, 1)).first()\\n if _layer:\\n # This is an existing layer\\n layers.append(_layer.id)\\n else:\\n # This is a new layer\\n try:\\n type_ = layer[\\\"type\\\"]\\n except:\\n type_ = None\\n try:\\n group_ = layer[\\\"group\\\"]\\n except:\\n group_ = None\\n try:\\n fixed = layer[\\\"fixed\\\"]\\n except:\\n fixed = None\\n try:\\n format = layer[\\\"format\\\"]\\n except:\\n format = None\\n try:\\n transparent = layer[\\\"transparent\\\"]\\n except:\\n transparent = None\\n # Add a new record to the gis_wmc_layer table\\n _layer = db.gis_wmc_layer.insert(source=layer[\\\"source\\\"], name=name, visibility=layer[\\\"visibility\\\"], opacity=opacity, type_=type_, title=layer[\\\"title\\\"], group_=group_, fixed=fixed, transparent=transparent, img_format=format)\\n layers.append(_layer)\\n\\n # @ToDo: Metadata (no way of editing this yet)\\n\\n # Update the record in the WMC table\\n db(db.gis_wmc.id == id).update(lat=lat, lon=lon, zoom=zoom, layer_id=layers)\\n\\n # Return the ID of the saved record for the Bookmark\\n output = json.dumps(dict(id=id))\\n return output\\n\\n # Abort - we shouldn't get here\\n raise HTTP(501)\",\n \"def home():\\n return (\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/<start><br/>\\\"\\n f\\\"/api/v1.0/<start>/<end>\\\"\\n \\n )\",\n \"def _map_base_url(base):\\n # This uses eventual consistency and cannot be made strongly consistent.\\n for rule in models_chromium.UrlMap.query().order(\\n models_chromium.UrlMap.base_url_template):\\n base_template = r'^%s$' % rule.base_url_template\\n match = re.match(base_template, base)\\n if not match:\\n continue\\n try:\\n src_url = re.sub(base_template,\\n rule.source_code_url_template,\\n base)\\n except re.error, err:\\n logging.error('err: %s base: \\\"%s\\\" rule: \\\"%s\\\" => \\\"%s\\\"',\\n err, base, rule.base_url_template,\\n rule.source_code_url_template)\\n return None\\n return src_url\\n return None\",\n \"def render_map(map,\\nlat=None,\\nlon=None,\\ntitle=None,\\nsave=True,\\nshow=True,\\nschedule=None,\\nschedule_bbox=(-0.03,0,1,0.91),\\nimg_filename=None,\\nimg_dir=\\\"\\\",\\nimg_size=[20,15],\\nimg_dpi=300,\\nimg_filetype=\\\"png\\\",\\nbrdr_nation=True,\\nbrdr_nation_rgba=[0,0,0,1],\\nbrdr_state=True,\\nbrdr_state_rgba=[0,0,0,0.75],\\ncmap=\\\"gist_ncar\\\",\\ncmap_limits=None,\\ncbar=True,\\ncbar_limits=None,\\ncbar_label=None,\\ncountry_focus=\\\"CHE\\\",\\ngridlines=True,\\ngridlines_dms=False,\\nmch_logo=True) :\\n\\n # TODO: Add custom sizing and resolution specifications\\n fig = plt.figure(figsize=(img_size[0]/2.54,img_size[1]/2.54))\\n\\n # TODO: Accept custom projections\\n # proj = ccrs.Mercator()\\n proj = ccrs.Orthographic(central_longitude=(lon[0]+lon[-1])/2, central_latitude=(lat[0]+lat[-1])/2)\\n\\n # TODO: Add support for multiple plots per figure (too complex? consider use cases)\\n ax = fig.add_subplot(1,1,1,projection = proj)\\n\\n # TODO: Increase flexibility of borders consideration\\n if brdr_state :\\n state_brdrs = cfeat.NaturalEarthFeature(\\n category='cultural',\\n name='admin_1_states_provinces_lines',\\n scale='10m',\\n facecolor='none')\\n ax.add_feature(state_brdrs,linestyle=\\\"--\\\",edgecolor=tuple(brdr_state_rgba),linewidth=0.5)\\n if brdr_nation :\\n ax.add_feature(cfeat.BORDERS,edgecolor=tuple(brdr_nation_rgba))\\n\\n if country_focus is not None :\\n shpfilename = shapereader.natural_earth(resolution='10m',\\n category='cultural',name='admin_0_countries')\\n reader = shapereader.Reader(shpfilename)\\n countries = reader.records() \\n # this is a very janky search for Switzerland, but it's ultimately simpler than\\n # making geopandas a requirement for the library\\n for country in countries :\\n if country.attributes['ADM0_A3'] == country_focus :\\n break\\n assert country.attributes['ADM0_A3'] == country_focus, \\\"country_focus input not recognised\\\"\\n poly = country.geometry\\n\\n msk_proj = proj.project_geometry (poly, ccrs.Geodetic()) # project geometry to the projection used by stamen\\n\\n # plot the mask using semi-transparency (alpha=0.65) on the masked-out portion\\n ax.add_geometries( msk_proj, proj, facecolor='white', edgecolor='none', alpha=0.8)\\n\\n # TODO: Consider first-last versus min-max - how can we avoid accidentally flipping images\\n extents=[lon[0],lon[-1],lat[0],lat[-1]]\\n ax.set_extent(extents,crs=ccrs.Geodetic())\\n\\n # this code correctly translate the lat/lon limits into the projected coordinates\\n extents_proj = proj.transform_points(ccrs.Geodetic(),np.array(extents[:2]),np.array(extents[2:]))\\n extents_proj = extents_proj[:,:2].flatten(order='F')\\n\\n if gridlines :\\n ax.gridlines(draw_labels=True, dms=gridlines_dms, x_inline=False, y_inline=False,linewidth=0.25,\\n ylocs=[46,46.5,47,47.5])\\n\\n # TODO: Custom colormaps, interpolation, cropping\\n\\n # Upscale matrix for better reprojection\\n # f = interp2d(lon, lat, map, kind='linear')\\n # latnew = np.linspace(lat[0], lat[-1], (len(lat)-1)*3+1)\\n # lonnew = np.linspace(lon[0], lon[-1], (len(lon)-1)*3+1)\\n # mapnew = f(lonnew, latnew)\\n\\n # Upscale matrix for better reprojection\\n mapnew = zoom(map,3)\\n\\n # show map with given cmap and set cmap limits\\n im = ax.imshow(mapnew,extent=extents,transform=ccrs.PlateCarree(),\\n origin='lower',cmap=cmap)\\n if cmap_limits is not None :\\n im.set_clim(cmap_limits[0],cmap_limits[1])\\n\\n # colorbar\\n # TODO: Add support for horizontal vertical option\\n if cbar :\\n cb = plt.colorbar(im, ax=ax, orientation='horizontal',pad=0.05,fraction=0.05)\\n cb.ax.set_xlabel(cbar_label)\\n\\n # show schedule diagram\\n if schedule is not None :\\n ax2 = inset_axes(ax, width=\\\"25%\\\", height=\\\"25%\\\", loc=2,\\n axes_class = get_projection_class('polar'),\\n bbox_to_anchor=tuple(schedule_bbox),\\n bbox_transform=ax.transAxes)\\n schedule_clock(ax2,schedule,title=\\\"Exposure schedule\\\")\\n\\n # TODO: Add more advanced title interpretation (i.e. smart date placeholder)\\n if title is not None :\\n ax.set_title(title)\\n\\n if mch_logo :\\n ex = ax.get_extent()\\n mch_logo_img = plt.imread('python_tamer/mch_logo.png')\\n mch_logo_width = 0.15\\n mch_logo_pad = 0\\n # some maths to work out position, note image aspect ratio 5:1\\n mch_extents = [ex[1]-(ex[1]-ex[0])*mch_logo_width-(ex[1]-ex[0])*mch_logo_pad,\\n ex[1]-(ex[1]-ex[0])*mch_logo_pad,\\n ex[2]+(ex[3]-ex[2])*mch_logo_pad,\\n ex[2]+0.2*(ex[1]-ex[0])*mch_logo_width+(ex[3]-ex[2])*mch_logo_pad]\\n # zorder puts image on top (behind mask otherwise for some reason)\\n ax.imshow(mch_logo_img,extent=mch_extents,zorder=12)\\n\\n # TODO: Add plot title, small textbox description, copyright from dataset, ticks and gridlines\\n if save :\\n # Generate timestamp filename if relying on default\\n if img_filename is None :\\n if title is not None :\\n img_filename = format_filename(title)\\n else :\\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\\n elif img_filename == \\\"timestamp\\\" :\\n img_filename=dt.datetime.now().strftime('%Y%m%d_%H%M%S_%f')\\n\\n plt.savefig(img_dir+img_filename+\\\".\\\"+img_filetype,\\n bbox_inches=\\\"tight\\\",dpi=img_dpi)\\n\\n if show :\\n plt.show()\",\n \"def _newurl(counter):\\n return \\\"%s/sitemap-%s.xml.gz\\\" % (settings.SITEMAPS_BASE_URL, counter)\",\n \"def home():\\n m = Map() # Create map html\\n return render_template('index.html') # pulls map html using jinja2\",\n \"def _createmap(self, family_x, color, place_list, reference):\\n dbstate = self.dbstate\\n self.cal = config.get('preferences.calendar-format-report')\\n self.place_list = place_list\\n self.place_without_coordinates = []\\n self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0\\n #self.minyear = 9999\\n #self.maxyear = 0\\n latitude = \\\"\\\"\\n longitude = \\\"\\\"\\n self.place_list = []\\n self.place_without_coordinates = []\\n self.minlat = self.maxlat = self.minlon = self.maxlon = 0.0\\n #family = self.dbstate.db.get_family_from_handle(family_x)\\n family = family_x\\n if family is None:\\n person = self.dbstate.db.get_family_from_handle(self.uistate.get_active('Person'))\\n if not person:\\n return\\n family_list = person.get_family_handle_list()\\n for family_hdl in family_list:\\n family = self.dbstate.db.get_family_from_handle(family_hdl)\\n if family is not None:\\n self._createmap_for_one_family(family, color, place_list, reference)\\n else:\\n self._createmap_for_one_family(family, color, place_list, reference)\\n #self._create_markers()\",\n \"def makeLandingUrl(self, artMeta):\\n self._readIssns()\\n issn = getIssn(artMeta)\\n if issn in self.highwireIssns:\\n baseUrl = self.highwireIssns[issn]\\n delayTime = self._highwireDelay(baseUrl)\\n vol = artMeta.get('vol', '')\\n issue = artMeta.get('issue', '')\\n page = artMeta.get('page', '')\\n if (vol, issue, page) != ('', '', '') and ' ' not in vol + issue + page:\\n url = '%s/content/%s/%s/%s.long' % (baseUrl,\\n vol,\\n issue,\\n page)\\n page = httpGetDelay(url, delayTime)\\n if page != None:\\n return url\\n if 'pmid' in artMeta:\\n url = '%s/cgi/pmidlookup?view=long&pmid=%s' % (baseUrl, artMeta['pmid'])\\n page = httpGetDelay(url, delayTime)\\n if page != None:\\n return url\\n return\",\n \"def fill_template(map_filepath, resolution, origin): # NOTE: Copied from generate_map_yaml.py\\n template = \\\"\\\"\\\"image: MAP_FILEPATH\\nresolution: RESOLUTION\\norigin: [ORIGIN_X, ORIGIN_Y, YAW]\\nnegate: 0\\noccupied_thresh: 0.65\\nfree_thresh: 0.196\\n\\\"\\\"\\\"\\n template = template.replace('MAP_FILEPATH', map_filepath)\\n template = template.replace('RESOLUTION', str(resolution))\\n template = template.replace('ORIGIN_X', str(origin[0]))\\n template = template.replace('ORIGIN_Y', str(origin[1]))\\n template = template.replace('YAW', str(origin[2]))\\n return template\",\n \"def _makeimap(self):\\n self.map_['source'] = 'GOES'\\n self.map_['provider'] = 'NOAA'\\n self.map_['instrument'] = 'SUVI'\\n self.map_['physobs'] = 'flux'\",\n \"def build_map(locations: list, user_location: tuple, year: int):\\n main_map = folium.Map(location=[user_location[0],\\n user_location[1]], zoom_start=4)\\n user_loc = folium.FeatureGroup(name=\\\"Your location\\\")\\n all_markers = folium.FeatureGroup(name=\\\"All markers location\\\", show=False)\\n ten_markers = folium.FeatureGroup(name=\\\"10 nearest markers\\\")\\n user_loc.add_child(folium.Marker(\\n location=[user_location[0], user_location[1]], popup='Your location',\\n icon=folium.Icon(color='red')))\\n for i in locations[10:]:\\n all_markers.add_child(folium.Marker(\\n location=[i[1][0], i[1][1]], popup=i[0], icon=folium.Icon(color='green')))\\n for i in locations[:10]:\\n ten_markers.add_child(folium.Marker(\\n location=[i[1][0], i[1][1]], popup=i[0], icon=folium.Icon()))\\n main_map.add_child(user_loc)\\n main_map.add_child(ten_markers)\\n main_map.add_child(all_markers)\\n main_map.add_child(folium.LayerControl())\\n map_name = str(year) + '_movies_map.html'\\n main_map.save(map_name)\",\n \"def formatUrl(url, searchTerms, startTime, endTime, bbox, limit=None, start=None):\\n \\n #interpolate searchTerms if not empty; otherwise remove parameter\\n if searchTerms == '':\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?searchTerms\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?searchTerms\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(searchTerms), url)\\n \\n #interpolate startTime if not empty; otherwise remove parameter\\n if startTime == '':\\n url = re.sub(r'(&?\\\\w+?)={time:start\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={time:start\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(startTime), url)\\n \\n #interpolate endTime if not empty; otherwise remove parameter\\n if endTime == '':\\n url = re.sub(r'(&?\\\\w+?)={time:end\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={time:end\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(endTime), url)\\n \\n #interpolate bbox if not empty; otherwise remove parameter\\n if bbox == '':\\n url = re.sub(r'(&?\\\\w+?)={geo:box\\\\??}', '', url)\\n url = re.sub(r'(&?\\\\w+?)={georss:box\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={geo:box\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(bbox), url)\\n url = re.sub(r'(&?\\\\w+?)={georss:box\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(bbox), url)\\n \\n #interpolate count if not empty; otherwise remove parameter\\n if limit is None:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?count\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?count\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(str(limit)), url)\\n \\n #interpolate startIndex if not empty; otherwise remove parameter\\n if start is None:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?startIndex\\\\??}', '', url)\\n else:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?startIndex\\\\??}', r'\\\\1=%s' %\\n urllib.quote_plus(str(start)), url)\\n \\n #interpolate startPage if not empty; otherwise remove parameter\\n if limit is None:\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?startPage\\\\??}', '', url)\\n else:\\n if start is not None: startPage = start/limit+1\\n else: startPage = 1\\n url = re.sub(r'(&?\\\\w+?)={(?:os:)?startPage\\\\??}',\\n urllib.quote_plus(str(startPage)), url) \\n \\n #clear out other template items\\n url = re.sub(r'(&?\\\\w+?)={\\\\w+?:\\\\w+\\\\??}', '', url)\\n \\n #replace ' ' with '+'\\n url = url.replace(' ', '+')\\n \\n return url\",\n \"def html_page():\\n return render_template('Map_twitter.html')\",\n \"def build_url (label, base, end):\\n clean_label = re.sub (r'([ ]+_)|(_[ ]+)|([ ]+)', '_', label)\\n return '%s%s%s' % (base, clean_label, end)\",\n \"def _get_basemap(self, projection='lambert', geopolygons=None, resolution='i', bound=True, hillshade=False):\\n\\t\\t# fig=plt.figure(num=None, figsize=(12, 12), dpi=80, facecolor='w', edgecolor='k')\\n\\t\\tminlat = self.attrs['minlat']\\n\\t\\tmaxlat = self.attrs['maxlat']\\n\\t\\tminlon = self.attrs['minlon']\\n\\t\\tmaxlon = self.attrs['maxlon']\\n\\t\\tlat_centre = (maxlat+minlat)/2.0\\n\\t\\tlon_centre = (maxlon+minlon)/2.0\\n\\t\\tif projection=='merc':\\n\\t\\t\\tm=Basemap(projection='merc', llcrnrlat=minlat-5., urcrnrlat=maxlat+5., llcrnrlon=minlon-5.,\\n\\t\\t\\t\\t\\t urcrnrlon=maxlon+5., lat_ts=20, resolution=resolution)\\n\\t\\t\\t# m.drawparallels(np.arange(minlat,maxlat,dlat), labels=[1,0,0,1])\\n\\t\\t\\t# m.drawmeridians(np.arange(minlon,maxlon,dlon), labels=[1,0,0,1])\\n\\t\\t\\tm.drawparallels(np.arange(-80.0,80.0,2.0), dashes=[2,2], labels=[1,0,0,0], fontsize=12)\\n\\t\\t\\tm.drawmeridians(np.arange(-170.0,170.0,2.0), dashes=[2,2], labels=[0,0,1,0], fontsize=12)\\n\\t\\t\\tm.drawstates(color='g', linewidth=2.)\\n\\t\\telif projection=='global':\\n\\t\\t\\tm=Basemap(projection='ortho',lon_0=lon_centre, lat_0=lat_centre, resolution=resolution)\\n\\t\\t\\t# m.drawparallels(np.arange(-80.0,80.0,10.0), labels=[1,0,0,1])\\n\\t\\t\\t# m.drawmeridians(np.arange(-170.0,170.0,10.0), labels=[1,0,0,1])\\n\\t\\telif projection=='regional_ortho':\\n\\t\\t\\tm1 = Basemap(projection='ortho', lon_0=minlon, lat_0=minlat, resolution='l')\\n\\t\\t\\tm = Basemap(projection='ortho', lon_0=minlon, lat_0=minlat, resolution=resolution,\\\\\\n\\t\\t\\t\\tllcrnrx=0., llcrnry=0., urcrnrx=m1.urcrnrx/mapfactor, urcrnry=m1.urcrnry/3.5)\\n\\t\\t\\tm.drawparallels(np.arange(-80.0,80.0,10.0), labels=[1,0,0,0], linewidth=2, fontsize=20)\\n\\t\\t\\t# m.drawparallels(np.arange(-90.0,90.0,30.0),labels=[1,0,0,0], dashes=[10, 5], linewidth=2, fontsize=20)\\n\\t\\t\\t# m.drawmeridians(np.arange(10,180.0,30.0), dashes=[10, 5], linewidth=2)\\n\\t\\t\\tm.drawmeridians(np.arange(-170.0,170.0,10.0), linewidth=2)\\n\\t\\telif projection=='lambert':\\n\\t\\t\\tdistEW, az, baz=obspy.geodetics.gps2dist_azimuth(minlat, minlon, minlat, maxlon) # distance is in m\\n\\t\\t\\tdistNS, az, baz=obspy.geodetics.gps2dist_azimuth(minlat, minlon, maxlat+2., minlon) # distance is in m\\n\\t\\t\\tm = Basemap(width=distEW, height=distNS, rsphere=(6378137.00,6356752.3142), resolution='l', projection='lcc',\\\\\\n\\t\\t\\t\\tlat_1=minlat, lat_2=maxlat, lon_0=lon_centre, lat_0=lat_centre)\\n\\t\\t\\tm.drawparallels(np.arange(-80.0,80.0,2.0), linewidth=1, dashes=[2,2], labels=[1,0,0,0], fontsize=12)\\n\\t\\t\\tm.drawmeridians(np.arange(-170.0,170.0,2.0), linewidth=1, dashes=[2,2], labels=[0,0,1,0], fontsize=12)\\n\\t\\t\\t# m.drawparallels(np.arange(-80.0,80.0,10.0), linewidth=0.5, dashes=[2,2], labels=[1,0,0,0], fontsize=5)\\n\\t\\t\\t# m.drawmeridians(np.arange(-170.0,170.0,10.0), linewidth=0.5, dashes=[2,2], labels=[0,0,0,1], fontsize=5)\\n\\t\\tm.drawcoastlines(linewidth=1.0)\\n\\t\\tm.drawcountries(linewidth=1.0)\\n\\t\\tm.drawstates(linewidth=1.0)\\n\\t\\t# m.drawmapboundary(fill_color=[1.0,1.0,1.0])\\n\\t\\t# m.fillcontinents(lake_color='#99ffff',zorder=0.2)\\n\\t\\t# m.drawlsmask(land_color='0.8', ocean_color='#99ffff')\\n\\t\\tm.drawmapboundary(fill_color=\\\"white\\\")\\n\\t\\tif bound:\\n\\t\\t\\ttry:\\n\\t\\t\\t\\t# m.readshapefile('/projects/howa1663/Code/ToolKit/Models/Plates/PB2002_boundaries', name='PB2002_boundaries', drawbounds=True, linewidth=1, color='orange') # draw plate boundary on basemap\\n\\t\\t\\t\\t#m.readshapefile('/work3/wang/code_bkup/AgeJdF/Plates/PB2002_boundaries', name='PB2002_boundaries', drawbounds=True, \\\\\\n\\t\\t\\t\\t#\\t\\tlinewidth=1, color='orange')\\n\\t\\t\\t\\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/ridge',name='ridge',drawbounds=True, linewidth=1, color='orange')\\n\\t\\t\\t\\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/trench',name='trench',drawbounds=True, linewidth=1, color='orange')\\n\\t\\t\\t\\tm.readshapefile('/work3/wang/code_bkup/ToolKit/Models/UT_Plates/transform',name='transform',drawbounds=True, linewidth=1, color='orange')\\n\\t\\t\\texcept IOError:\\n\\t\\t\\t\\tprint(\\\"Couldn't read shape file! Continue without drawing plateboundaries\\\")\\n\\t\\ttry:\\n\\t\\t\\tgeopolygons.PlotPolygon(inbasemap=m)\\n\\t\\texcept:\\n\\t\\t\\tpass\\n\\t\\tif hillshade:\\n\\t\\t\\tfrom netCDF4 import Dataset\\n\\t\\t\\tfrom matplotlib.colors import LightSource\\n\\t\\t\\tetopo1 = Dataset('/work2/wang/Code/ToolKit/ETOPO1_Ice_g_gmt4.grd','r')\\n\\t\\t\\tzz = etopo1.variables[\\\"z\\\"][:]\\n\\t\\t\\tllons = etopo1.variables[\\\"x\\\"][:]\\n\\t\\t\\twest = llons<0 # mask array with negetive longitudes\\n\\t\\t\\twest = 360.*west*np.ones(len(llons))\\n\\t\\t\\tllons = llons+west\\n\\t\\t\\tllats = etopo1.variables[\\\"y\\\"][:]\\n\\t\\t\\tetopoz = zz[(llats>(minlat-2))*(llats<(maxlat+2)), :]\\n\\t\\t\\tetopoz = etopoz[:, (llons>(minlon-2))*(llons<(maxlon+2))]\\n\\t\\t\\tllats = llats[(llats>(minlat-2))*(llats<(maxlat+2))]\\n\\t\\t\\tllons = llons[(llons>(minlon-2))*(llons<(maxlon+2))]\\n\\t\\t\\tls = LightSource(azdeg=315, altdeg=45)\\n\\t\\t\\tetopoZ = m.transform_scalar(etopoz, llons-360*(llons>180)*np.ones(len(llons)), llats, etopoz.shape[0], etopoz.shape[1])\\n\\t\\t\\tls = LightSource(azdeg=315, altdeg=45)\\n\\t\\t\\tm.imshow(ls.hillshade(etopoZ, vert_exag=1.),cmap='gray')\\n\\t\\treturn m\",\n \"def url(self):\\n\\t\\treturn self.base_url+\\\"{}/{}/{}.jpg\\\".format(self.template,self._escape(self.top_text),self._escape(self.bottom_text))+(\\\"?\\\"+\\\"&\\\".join([\\\"{}={}\\\".format(k,quote(self.kwargs[k])) for k in self.kwargs]) if self.kwargs else \\\"\\\")\",\n \"def build_url(self):\\n url = requests.utils.requote_uri(\\n self.torrent_page + self.string_search)\\n if self.page == '1337x':\\n return(url + '/1/')\\n elif self.page == 'limetorrents':\\n return(url + '/')\\n else:\\n return(url)\",\n \"def __init__(self, lat, lng):\\n self.summary = \\\"Lorem ipsum\\\"\",\n \"def main() -> None:\\n map_ssh = folium.Map(location=[45.523, -122.675], zoom_start=2)\\n\\n with open(\\\"lib/base_data.txt\\\") as tsv:\\n for row in csv.reader(tsv, delimiter=\\\"\\\\t\\\"):\\n name = row[0]\\n try:\\n x = float(row[1])\\n y = float(row[2])\\n folium.Marker([x, y], popup=name).add_to(map_ssh)\\n except ValueError:\\n pass\\n\\n map_ssh.save(\\\"map_ssh.html\\\")\",\n \"def build_map(n=30,m=30, preset=True, filename='/home/sji367/small_grid.mat', key='new_grid'):\\n if preset:\\n the_map = []\\n row = [0] * n\\n for i in range(m):\\n the_map.append(list(row))\\n \\n # fillout the map matrix with a '+' pattern\\n for x in range(n / 8, n * 7 / 8):\\n the_map[m / 2][x] = 1\\n for y in range(m/8, m * 7 / 8):\\n the_map[y][n / 2] = 1\\n \\n # randomly select start and finish locations from a list\\n sf = []\\n sf.append((0, 0, n - 1, m - 1))\\n sf.append((0, m - 1, n - 1, 0))\\n sf.append((n / 2 - 1, m / 2 - 1, n / 2 + 1, m / 2 + 1))\\n sf.append((n / 2 - 1, m / 2 + 1, n / 2 + 1, m / 2 - 1))\\n sf.append((n / 2 - 1, 0, n / 2 + 1, m - 1))\\n sf.append((n / 2 + 1, m - 1, n / 2 - 1, 0))\\n sf.append((0, m / 2 - 1, n - 1, m / 2 + 1))\\n sf.append((n - 1, m / 2 + 1, 0, m / 2 - 1))\\n (xStart, yStart, xFinish, yFinish) = random.choice(sf)\\n else:\\n grid = loadmat(filename)\\n the_map = grid[key]\\n xStart = 19\\n yStart = 31\\n xFinish = 67\\n yFinish = 98\\n \\n return the_map, xStart, yStart, xFinish, yFinish\",\n \"def _onbuttonReqMapClicked(self):\\n\\n day1=str(self.combo_wms_time_first_d.currentText())\\n hour1=str(self.combo_wms_time_first_h.currentText())\\n date_val=day1+hour1\\n depth=str(self.combo_wms_layer_depth.currentText())\\n variable=str(self.combo_variable_list.currentText())\\n product=str(self.combo_product_list.currentText())\\n dataset=str(self.combo_dataset_list.currentText())\\n xmin=int(float(self.WMS_westBound.text()))\\n xmax=int(float(self.WMS_eastBound.text()))\\n ymin=int(float(self.WMS_southBound.text()))\\n ymax=int(float(self.WMS_northBound.text()))\\n dir_out=self.tmp\\n rastermin=self.minscale_value.text()\\n rastermax=self.maxscale_value.text()\\n nb_colors=self.nbcolors_value.text()\\n xpixels=float(self.Xpixels_value.text())\\n xparallels=int(self.Xparallels_value.text())\\n ymeridians=int(self.Ymedians_value.text())\\n dpi=300\\n colorbar=str(self.combo_colorbar.currentText())\\n input_srs=str(self.combo_proj.currentText())\\n epsg_val=input_srs.split(':')[1]\\n ll_polar=False\\n##\\tif self.checkBox_2.isChecked() == True :\\n##\\t print \\\"Projection arctic\\\"\\n## #m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\\n## # urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \\n## ##m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \\n## m = Basemap(projection='npstere',boundinglat=ymin,lon_0=0,round=True,resolution='l') \\n## #Proj4js.defs[\\\"EPSG:3408\\\"] = \\\"+proj=laea +lat_0=90 +lon_0=0 +x_0=0 +y_0=0 +a=6371228 +b=6371228 +units=m +no_defs\\\";\\n## #\\n## ll_polar=True\\n##\\telif self.checkBox_3.isChecked() == True :\\n##\\t print \\\"Projection antarctic\\\"\\n## m = Basemap(projection='spstere',boundinglat=ymax,lon_0=180,round=True,resolution='l') \\n## ll_polar=True\\n##\\telse : \\n m = Basemap(llcrnrlon=xmin, urcrnrlat=ymax,\\n urcrnrlon=xmax, llcrnrlat=ymin,resolution='l',epsg=epsg_val) \\n print \\\"cylindric projection\\\"\\n\\n # ypixels not given, find by scaling xpixels by the map aspect ratio.\\n ypixels = int(m.aspect*xpixels)\\n style='boxfill/'+colorbar\\n print input_srs\\n print epsg_val\\n p = pyproj.Proj(init=\\\"epsg:%s\\\" % epsg_val, preserve_units=True)\\n xmin,ymin = p(m.llcrnrlon,m.llcrnrlat)\\n xmax,ymax = p(m.urcrnrlon,m.urcrnrlat)\\n if epsg_val == '4326' :\\n xmin = (180./np.pi)*xmin; xmax = (180./np.pi)*xmax\\n ymin = (180./np.pi)*ymin; ymax = (180./np.pi)*ymax\\n print \\\"Cylindric projection\\\"\\n print xmin,xmax,ymin,ymax\\n print style\\n img = self.wms.getmap(layers=[variable],service='wms',bbox=(xmin,ymin,xmax,ymax),\\n size=(int(xpixels),ypixels),\\n format='image/png',\\n elevation=depth,\\n srs=input_srs,\\n time=date_val,\\n colorscalerange=rastermin+','+rastermax,numcolorbands=nb_colors,logscale=False,\\n styles=[style])\\n image=imread(io.BytesIO(img.read()),format='png')\\n if variable == \\\"sea_water_velocity\\\" :\\n ylabel=\\\"magnitude\\\"\\n else :\\n ylabel=self.wms[variable].abstract\\n\\n long_name=self.wms[variable].title\\n title=product+\\\" - \\\"+long_name+\\\" \\\"+\\\" - \\\"+date_val\\n file_pal='./palettes/thredds/'+colorbar+'.pal'\\n my_cmap=compute_cmap(file_pal,colorbar)\\n cm.register_cmap(name=colorbar, cmap=my_cmap)\\n font=10\\n norm = mpl.colors.Normalize(vmin=float(rastermin), vmax=float(rastermax), clip=False) \\n parallels=np.round(np.arange(ymin,ymax+xparallels/2,xparallels))\\n meridians = np.round(np.arange(xmin,xmax+ymeridians/2,ymeridians))\\n # Plot figure \\n plt.figure(figsize=(20,12))\\n if epsg_val == '4326' :\\n m.drawcoastlines(color='lightgrey',linewidth=0.25)\\n m.fillcontinents(color='lightgrey')\\n m.drawmeridians(meridians,labels=[0,0,0,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\\n\\n elif ll_polar == True : \\n #m.drawcoastlines(linewidth=0.5)\\n m.drawparallels(parallels,labels=[1,0,0,0],fontsize=10,linewidth=0.2)\\n m.drawmeridians(meridians[:-1],labels=[1,1,1,1],fontsize=10,linewidth=0.2,dashes=[1, 5])\\n ## Plot the image\\n cs=m.imshow(image,origin='upper',alpha=1,cmap=(cm.get_cmap(colorbar,int(nb_colors))),norm=norm)\\n ## Add colorbar\\n cb=plt.colorbar(cs,orientation='vertical',format='%4.2f',shrink=0.7)\\n cb.ax.set_ylabel(ylabel, fontsize=int(font)+4)\\n cl=plt.getp(cb.ax, 'ymajorticklabels')\\n plt.setp(cl, fontsize=font)\\n\\n plt.title(title,fontsize=font+4,y=1.05)\\n plt.savefig('images/'+product+\\\"_\\\"+long_name+\\\"_\\\"+date_val+\\\"_basemap.png\\\",dpi=300,bbox_inches='tight')\\n plt.show()\",\n \"def sampleAndDownloadStreetImage(endPoints, sampleNum, picNum, ptrNum, targetDirectory, intersectionPointInfo):\\n print \\\"downloading street images...\\\"\\n sampledPoints = random.sample(endPoints, sampleNum) if sampleNum < len(endPoints) else endPoints\\n sampleData = [] # store (picture number, file name, lat and lng)\\n progress = Progress(10)\\n headings = CONFIG[\\\"gmap\\\"][\\\"headings\\\"]\\n sampleNumDelta = len(headings)\\n for point in sampledPoints:\\n progress.printProgress()\\n result = downloadSurroundingStreetView(point, targetDirectory, picNum, ptrNum, intersectionPointInfo)\\n sampleData += result\\n picNum += sampleNumDelta\\n ptrNum += 1\\n print \\\"\\\"\\n return sampleData\",\n \"def build_url(vehicle, coordinates, format=\\\"json\\\", geometryformat=\\\"isoz\\\"):\\n load = vehicle.load if vehicle.load > -1.0 else 0\\n params = {\\n \\\"format\\\": format,\\n \\\"height\\\": vehicle.height,\\n \\\"length\\\": vehicle.length,\\n \\\"stops\\\": coordinates,\\n \\\"load\\\": load,\\n \\\"geometryformat\\\": geometryformat,\\n \\\"lang\\\": \\\"nb-no\\\",\\n }\\n\\n return '?'.join([ROUTE_URL_BASE, urlencode(params)])\",\n \"def customization_data(client=None):\\n\\n # This import data contains:\\n # Function inputs:\\n # google_maps_destination\\n # google_maps_origin\\n # Message Destinations:\\n # fn_google_maps_directions\\n # Functions:\\n # fn_google_maps_directions\\n # Workflows:\\n # example_google_maps_directions\\n # Rules:\\n # Get Directions\\n\\n\\n yield ImportDefinition(u\\\"\\\"\\\"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\\nLCAiZXhwb3J0X2RhdGUiOiAxNTM5ODY3NjgwMjk5fQ==\\n\\\"\\\"\\\"\\n )\",\n \"def random_gps_gen_from_range(s_lat,n_lat, e_lon, w_lon):\\n #print(s_lat, n_lat, e_lon, w_lon)\\n latitude = random.uniform(s_lat, n_lat)\\n longitude = random.uniform(e_lon, w_lon)\\n return latitude, longitude\",\n \"def roadSegments(locations, API_key=\\\"Avah46_M-gfFeQ3P1w09Qq1ElAV9ZEHFDm9b8JRCRa8qPP5uVn21hDqAPVJgV4i_\\\"): \\n \\n # Base URL\\n uri = 'http://dev.virtualearth.net/' # Resource URL \\n path = 'REST/v1/Routes?'\\n \\n \\n # URL Parameters\\n params = { 'wayPoint.0' : locations[0]+',Singapore',\\n 'wayPoint.1' : locations[1]+',Singapore',\\n 'routeAttributes':'routePath',\\n 'key' : API_Key} # by default 'optimize' : 'time'} # this is by default\\n \\n url = uri+path\\n\\n results = requests.get(\\n url,\\n params = params\\n ).json()# ['resourceSets']\\n\\n # Retrieving values\\n statusCode = results['statusCode']\\n if statusCode == 200:\\n # print(statusCode)\\n\\n # TODO review the exceptions and modify these basic exception handlings\\n try:\\n travelDistance = results['resourceSets'][0]['resources'][0]['travelDistance']\\n except:\\n travelDistance = 0\\n try:\\n travelDuration = results['resourceSets'][0]['resources'][0]['travelDuration']\\n except:\\n travelDuration = 0\\n try:\\n travelDurationTraffic = results['resourceSets'][0]['resources'][0]['travelDurationTraffic']\\n except:\\n travelDurationTraffic = 0\\n\\n try:\\n numberSegments = len(results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\\\\n ['itineraryItems'])\\n except:\\n numberSegments = 0\\n try:\\n itineraryItems = results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\\\\n ['itineraryItems']\\n except:\\n itineraryItems = 'No items'\\n\\n pathCoord = results['resourceSets'][0]['resources'][0]['routePath']['line']['coordinates']\\n\\n roadName = []\\n travelDistances = []\\n travelDurations = []\\n maneuverType = []\\n\\n for seg in itineraryItems:\\n for i in range(len(seg['details'])):\\n # print(i)\\n try:\\n roadName.append(seg['details'][i]['names'])\\n except:\\n roadName.append(0)\\n try:\\n travelDistances.append(seg['travelDistance'])\\n except:\\n travelDistances.append(0)\\n\\n try:\\n travelDurations.append(seg['travelDuration'])\\n except:\\n travelDurations.append(0)\\n try:\\n maneuverType.append(seg['details'][i]['maneuverType'])\\n except:\\n maneuverType.append(0)\\n\\n\\n return statusCode,travelDistance,travelDuration,travelDurationTraffic,numberSegments,roadName, \\\\\\n travelDistances, travelDurations, maneuverType, pathCoord\\n\\n else:\\n print(\\\"Unsuccessful route calculation.\\\")\",\n \"def map(request, template):\\n lender_selected = request.GET.get('lender', '')\\n metro_selected = request.GET.get('metro')\\n year_selected = int(request.GET.get('year',str(Year.objects.latest().hmda_year)))\\n context = {}\\n lender = Institution.objects.filter(institution_id=lender_selected).select_related('agency', 'zip_code', 'lenderhierarchy').first()\\n metro = Geo.objects.filter(geo_type=Geo.METRO_TYPE,geoid=metro_selected).first()\\n \\n if lender:\\n context['lender'] = lender\\n hierarchy_list = lender.get_lender_hierarchy(True, True, year_selected)\\n context['institution_hierarchy'] = hierarchy_list \\n if metro:\\n context['metro'] = metro\\n context['year'] = year_selected\\n if lender and metro:\\n peer_list = lender.get_peer_list(metro, True, True) \\n context['institution_peers'] = peer_list\\n context['download_url'] = make_download_url(lender, metro)\\n context['hierarchy_download_url'] = make_download_url(hierarchy_list, metro)\\n context['peer_download_url'] = make_download_url(peer_list, metro)\\n context['median_loans'] = lookup_median(lender, metro) or 0\\n if context['median_loans']:\\n # 50000 is an arbitrary constant; should be altered if we want to\\n # change how big the median circle size is\\n context['scaled_median_loans'] = 50000 / context['median_loans']\\n else:\\n context['scaled_median_loans'] = 0\\n return render(request, template, context)\",\n \"def search_geoloc_range(request):\\n\\n distance = float(request.POST['distance'])\\n\\n latlng = (request.POST['latlng']).replace(\\\"(\\\",'').replace(\\\")\\\",'').split(', ')\\n latitude = float(latlng[0])\\n longitude = float(latlng[1])\\n print distance\\n print latitude\\n print longitude\\n\\n # count range of nowa latlng\\n radius_lat = (distance/(69.172)) #count latitude range\\n min_lat = latitude - radius_lat\\n max_lat = latitude + radius_lat\\n print min_lat\\n print max_lat\\n\\n radius_lng = (math.fabs(distance/(math.cos(longitude) * 69.172))) #count longitude range\\n min_lng = longitude - radius_lng\\n max_lng = longitude + radius_lng\\n print min_lng\\n print max_lng\\n\\n # if sys.version_info < (2, 7):\\n # min_lat = decimal.Decimal(str(min_lat))\\n # max_lat = decimal.Decimal(str(max_lat))\\n # min_lng = decimal.Decimal(str(min_lng))\\n # max_lng = decimal.Decimal(str(max_lng))\\n\\n # query db to match the range of dentist work place in db\\n total = WorkPlace.objects.filter(latitude__gte=min_lat, latitude__lte=max_lat,\\n longitude__gte=min_lng, longitude__lte=max_lng).count()\\n\\n result = []\\n\\n # step for how many lines separate per page. then count nowa page's start line no. and end line no.\\n if 'page' in request.POST:\\n page = request.POST['page']\\n else:\\n page = 1\\n\\n step = 10\\n end = step * int(page)\\n start = step * (int(page)-1)\\n is_end = False\\n\\n if (end - total) < step:\\n is_end = False\\n WorkPlaceDict = WorkPlace.objects.filter(latitude__gte=min_lat, latitude__lte=max_lat,\\n longitude__gte=min_lng, longitude__lte=max_lng).order_by('id')[start:end]\\n\\n for i in WorkPlaceDict:\\n\\n dentist_profile = i.dentistid\\n did = dentist_profile.user.user.id\\n\\n latitude = str(i.latitude)\\n longitude = str(i.longitude)\\n latlng = \\\"(\\\"+latitude+\\\", \\\"+longitude+\\\")\\\"\\n\\n counts = _relation_counts(request,did,request.user.id)\\n\\n i_wrap = {\\n \\\"clinic\\\": i.clinic_name,\\n \\\"work_location\\\": i.location,\\n \\\"latlng\\\": latlng,\\n \\\"business_hour\\\": str(i.business_hour),\\n \\\"dentistid\\\": did,\\n \\\"dentistname\\\": _show_obj_name(did),\\n \\\"summary\\\": dentist_profile.user.summary,\\n \\\"avatar\\\": settings.MEDIA_URL + str(dentist_profile.user.imagesmall),\\n \\\"patient_count\\\": counts[\\\"patient_count\\\"],\\n \\\"follower_count\\\": counts[\\\"follower_count\\\"],\\n \\\"status\\\": counts[\\\"status\\\"],\\n \\\"is_end\\\": is_end\\n }\\n\\n result.append(i_wrap)\\n\\n else:\\n is_end = True\\n i_wrap = {\\n \\\"is_end\\\": is_end\\n }\\n\\n result.append(i_wrap)\\n\\n template_var = {\\n \\\"searchresult\\\": result\\n }\\n\\n return JsonResponse(template_var)\",\n \"def write_google_map_range_header(outfile: TextIO, map_name: str) -> None:\\n outfile.write(\\\" var range_map = new google.maps.Map(document.getElementById(\\\\\\\"range_map_canvas\\\\\\\"),\\\"\\n \\\"mapOptions);\\\\n\\\")\\n outfile.write(\\\" var range_layer = new google.maps.KmlLayer(\\\\\\\"\\\" + init_data().site_url() + \\\"/maps/\\\" +\\n rangemap_name(map_name) + \\\".kmz\\\\\\\",{suppressInfoWindows: true});\\\\n\\\")\\n outfile.write(\\\" range_layer.setMap(range_map);\\\\n\\\")\",\n \"def request_url(request):\\n \\n shot = request.GET['shot']\\n path = request.GET['path']\\n tree = request.GET['tree']\\n\\n xml_elmt = '{http://h1svr.anu.edu.au/}dataurlmap'\\n lang_attr = {'{http://www.w3.org/XML/1998/namespace}lang': 'en'}\\n url_xml = etree.Element(xml_elmt, attrib=lang_attr)\\n \\n shot_number = etree.SubElement(url_xml, 'shot_number', attrib={})\\n shot_number.text = shot\\n data_path = etree.SubElement(url_xml, 'path', attrib={})\\n data_path.text = path\\n data_tree = etree.SubElement(url_xml, 'tree', attrib={})\\n data_tree.text = tree\\n\\n url_processor = URLProcessor(shot=int(shot), tree=tree, path=path)\\n url = url_processor.get_url()\\n url_el = etree.SubElement(url_xml, 'url', attrib={})\\n url_el.text = url\\n\\n return HttpResponse(etree.tostring(url_xml),\\n mimetype='text/xml; charset=utf-8')\",\n \"def Home():\\n return(\\n f\\\"Hawaii Climate Routes:<br/>\\\"\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/<start><br/>\\\"\\n f\\\"and<br/>\\\"\\n f\\\"/api/v1.0/<start>/<end>\\\"\\n )\",\n \"def find_image_url(lat_value, long_value):\\n global custom_memory, custom_hit, custom_miss, total_custom_memory\\n image_tuple = (lat_value, long_value)\\n \\n #When Latitude Longitude in Cache and HIT\\n if image_tuple in custom_memory:\\n custom_hit+=1\\n custom_memory[image_tuple][1] = datetime.now()\\n return custom_memory[image_tuple][0],\\\"hit\\\"\\n \\n #When Latitude Longitude NOT in Cache and MISS\\n if len(custom_memory) < total_custom_memory:\\n custom_miss+=1\\n custom_memory[image_tuple] = [GetImageURL(*image_tuple), datetime.now()]\\n return custom_memory[image_tuple][0], \\\"miss_when_not_full\\\"\\n else:\\n custom_memory = sorted([(key, list_vals) for key, list_vals in custom_memory.items()], key=lambda i:i[1][1], reverse=False)\\n del custom_memory[0]\\n custom_memory = dict(custom_memory)\\n custom_miss+=1\\n custom_memory[image_tuple] = [GetImageURL(*image_tuple), datetime.now()]\\n return custom_memory[image_tuple][0], \\\"miss_when_after_full\\\"\",\n \"def send_map_data():\\n\\n avg_lat = 37.75774\\n avg_long = -122.43870\\n bounds = {'lat': [-122.54, -122.35], 'lng': [37.67, 37.84]}\\n center = {'lat': avg_lat, 'lng': avg_long}\\n\\n return jsonify({'map_center': center,\\n 'map_bounds': bounds,\\n })\",\n \"def _make_url(self):\\n ...\",\n \"def search_geoloc_range_fixed_loc(request):\\n\\n patient_profile = PatientProfile.objects.get(user=request.user)\\n fixed_location = patient_profile.location\\n\\n latitude = str(patient_profile.latitude)\\n longitude = str(patient_profile.longitude)\\n latlng = \\\"(\\\"+latitude+\\\", \\\"+longitude+\\\")\\\"\\n print latlng\\n \\n template_var = {\\n \\\"mylocation\\\": fixed_location,\\n \\\"latlng\\\": latlng\\n }\\n\\n return template_var\",\n \"def buildSFOUrls(jd_start, jd_stop):\\n url_list = []\\n time_list = ['03z', '09z', '15z', '21z']\\n delta = jd_stop-jd_start\\n for i in range((delta.days)+1):\\n model_file_date = jd_start + timedelta(days=i)\\n base_url = ('http://opendap.co-ops.nos.noaa.gov/'\\n 'thredds/dodsC/NOAA/SFBOFS/MODELS/')\\n val_month, val_year, val_day = '', '', ''\\n # Month.\\n if model_file_date.month < 10:\\n val_month = \\\"0\\\" + str(model_file_date.month)\\n else:\\n val_month = str(model_file_date.month)\\n # Year.\\n val_year = str(model_file_date.year)\\n # Day.\\n if model_file_date.day < 10:\\n val_day = \\\"0\\\" + str(model_file_date.day)\\n else:\\n val_day = str(model_file_date.day)\\n file_name = '/nos.sfbofs.stations.nowcast.'\\n file_name += val_year + val_month + val_day\\n for t in time_list:\\n t_val = '.t' + t + '.nc'\\n url_list.append(base_url + val_year + val_month +\\n file_name + t_val)\\n return url_list\",\n \"def _makeWGSurl(WGSline) :\\n if not WGSline.startswith(\\\"WGS \\\") :\\n raise Exception(\\\"Line does not start with \\\\\\\"WGS \\\\\\\"\\\")\\n accession = WGSline.split(\\\" \\\")[-1]\\n accRoot = accession.split(\\\"-\\\")[0][0:6]\\n url = \\\"http://www.ncbi.nlm.nih.gov/Traces/wgs/?download=\\\" + accRoot + \\\".1.gbff.gz\\\"\\n return url\",\n \"def makeRouteRequest(latLongs):\\n global headersGlobal, routeURL_synchronous # get global variables\\n\\n key = variables.bingMapsAPIKey # api key\\n # construct the URL\\n url = routeURL_synchronous + \\\"wp.0=\\\" + str(latLongs[0][0]) + \\\",\\\" + str(latLongs[0][1]) + \\\"&wp.1=\\\" + str(\\n latLongs[1][0]) + \\\",\\\" + str(latLongs[1][1]) + \\\"&key=\\\" + key\\n\\n request = requests.get(url, headers=headersGlobal) # make the request\\n return request # return the request\",\n \"def create_url(self, keywords, start, end, region=None, category=None):\\n # Replace the '+' symbol in a keyword with '%2B'\\n keywords = [re.sub(r'[+]', '%2B', kw) for kw in keywords]\\n # Replace white spaces in a keyword with '%20'\\n keywords = [re.sub(r'\\\\s', '%20', kw) for kw in keywords]\\n # Define main components of the URL\\n base = \\\"https://trends.google.com/trends/explore\\\"\\n geo = f\\\"geo={region}&\\\" if region is not None else \\\"\\\"\\n query = f\\\"q={','.join(keywords)}\\\"\\n cat = f\\\"cat={category}&\\\" if category is not None else \\\"\\\"\\n # Format the datetime objects to strings in the format used by google\\n start_string = datetime.strftime(start, self._google_date_format)\\n end_string = datetime.strftime(end, self._google_date_format)\\n # Define the date-range component for the URL\\n date = f\\\"date={start_string}%20{end_string}\\\"\\n # Construct the URL\\n url = f\\\"{base}?{cat}{date}&{geo}{query}\\\"\\n return url\",\n \"def mapdata(self):\\n return {\\n 'lat': str(self.location.latitude),\\n 'lng': str(self.location.longitude),\\n 'options': {\\n 'icon': self.species.marker.url\\n },\\n 'data': {\\n 'href': str(self.get_absolute_url())\\n }\\n }\",\n \"def generate_xmap(x_len, y_len, all_cids, all_xcoords, all_ycoords):\\r\\n # Determine figure height and width\\\"\\\"\\\"\\r\\n img_height = x_len * 80\\r\\n img_width = y_len * 80\\r\\n\\r\\n # Write html script which allows for mouseover of labels\\r\\n xmap = []\\r\\n for cid, x, y in zip(all_cids, all_xcoords, all_ycoords):\\r\\n xmap.append(AREA_SRC % (x, img_height - y, cid, cid))\\r\\n\\r\\n return xmap, img_height, img_width\",\n \"def map(request):\\n # Test Comment\\n assert isinstance(request, HttpRequest)\\n return render(\\n request,\\n 'map.html',\\n context_instance=RequestContext(request, {})\\n )\",\n \"def fetch_url_gevent(sitemap, base, url):\\n print \\\"starting\\\", url\\n markup = html.document_fromstring(requests.get(url).content)\\n print \\\"got\\\", url\\n markup.make_links_absolute(base)\\n statics, links = getstatic(markup), getlinks_to(markup, base)\\n sitemap.add_node(url, statics=statics, links=links)\\n for link in links:\\n sitemap.add_edge(url, link)\\n return links\",\n \"def createMap(title_in, file_in, fig_file_in, N, vmin, vmax, lon_in,\\n lat_in, sss_in, colors, label='SSS [PSS]'):\\n\\n fig = plt.figure()\\n ax = fig.add_subplot(111)\\n ax.set_title(title_in)\\n plt.figtext(1, 0, file_in, ha='right', va='bottom', fontsize=6)\\n\\n map = Basemap(projection='moll', resolution='l', lon_0=-50, ellps='WGS84', anchor='S')\\n map.drawcoastlines(linewidth=0.01, antialiased=False)\\n map.drawmapboundary(fill_color='white', linewidth=0.01)\\n map.drawmeridians(np.arange(-180,181,60), labels=[0,0,0,0], linewidth=0.01, labelstyle=None)\\n map.drawparallels(np.arange(-90,91,30), labels=[1,0,0,0], linewidth=0.01, labelstyle=None) \\n map.fillcontinents(color='grey')\\n\\n ticks = np.linspace(vmin, vmax, N+1)\\n \\n lonout, z = map.shiftdata(lon_in, sss_in, lon_0=-50)\\n lon, lat = np.meshgrid(lonout, lat_in)\\n x, y = map(lon, lat)\\n\\n cmap = cm.get_cmap(colors, N)\\n cmap.set_bad('1.0')\\n cmap.set_under((0.0, 0.0, 0.25, 1.0))\\n cmap.set_over((0.25, 0.0, 0.0, 1.0))\\n\\n pc = map.pcolormesh(x, y, z, vmin=vmin, vmax=vmax, cmap=cmap)\\n cb = plt.colorbar(pc, shrink=0.8, orientation='horizontal', fraction=0.04, extend ='both', ticks=ticks)\\n cb.set_label(label)\\n plt.savefig(fig_file_in)\\n logging.debug(fig_file_in +' .... created!' )\\n plt.close()\\n\\n return None\",\n \"def plot_html(lats, lons, zoom=11, heatmap=True, scatter=True):\\n gmap = gmplot.GoogleMapPlotter(np.median(lats), np.median(lons), zoom=zoom)\\n \\n if heatmap: gmap.heatmap(lats, lons)\\n if scatter: gmap.scatter(lats, lons, 'k', size=6, marker=False)\\n gmap.draw(\\\"/Users/ulfaslak/Desktop/mymap.html\\\")\",\n \"def create_maps(self,data,tod,mjd,coords):\\n features = np.log10(self.getFeatures(data))/np.log10(2)\\n special_idx = np.where((features==16))[0]\\n # This is for getting the stare data on more recent\\n # calibration observations.\\n point_data = self.get_point_data(data,special_idx)\\n \\n cel_maps = self.create_single_map(tod,\\n coords['ra'],\\n coords['dec'],\\n self.source_positions['ra'][coords['sky_data_flag']],\\n self.source_positions['dec'][coords['sky_data_flag']])\\n az_maps = self.create_single_map(tod,\\n coords['az'],\\n coords['el'],\\n self.source_positions['az'][coords['sky_data_flag']],\\n self.source_positions['el'][coords['sky_data_flag']])\\n cel_maps= self.average_maps(cel_maps)\\n az_maps = self.average_maps(az_maps)\\n xygrid = np.meshgrid((np.arange(self.Nx)+0.5)*self.dx - self.Nx*self.dx/2.,\\n (np.arange(self.Ny)+0.5)*self.dy - self.Ny*self.dy/2.)\\n \\n \\n cel_maps['xygrid']=xygrid\\n cel_maps['StareCoords']= {**point_data,'pa':np.nanmean(self.source_positions['pa'])}\\n az_maps['xygrid']=xygrid\\n az_maps['StareCoords'] = {**point_data,'pa':np.nanmean(self.source_positions['pa'])}\\n return cel_maps,az_maps\",\n \"def view_map():\\n print(\\\"\\\"\\\"\\n ____________________________________Client Rooms______________________\\n| |1 Locker Rooms 2| 1 | 2 | |\\n| |_________ ________| | | Dance |\\n| | | |__| |__| Floor |\\n| | | Hall |\\n| Garage | Front | _______|_______ |\\n| | Lobby | | |_ ____________|\\n| | | | Storage |\\n| | | Lounge |______________|\\n| ______________ Car\\n|___________________Front Entrance______________________| Allyway\\n\\\"\\\"\\\")\",\n \"def create_guardian_search_url(api_key, query, page, from_date, to_date):\\n\\n # format base url\\n url = '%s?page-size=%s&show-fields=%s&q=%s&page=%s&api-key=%s' % (\\n GUARDIAN_SEARCH_API, PAGE_SIZE, SHOW_FIELDS, query, page, api_key\\n )\\n\\n # add from-date query, if exists\\n if (from_date):\\n url += '&from-date=%s' % (from_date)\\n\\n # add to-date query, if exists\\n if (to_date):\\n url += '&to-date=%s' % (to_date)\\n\\n return url\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7412921","0.7408514","0.6695499","0.6539618","0.65338993","0.64012855","0.6347697","0.62790763","0.625587","0.61357576","0.60827684","0.60016644","0.5909071","0.5871183","0.5864181","0.58204234","0.57807314","0.5719914","0.57073295","0.5690754","0.56851184","0.5678762","0.56695163","0.5629338","0.56254816","0.5602676","0.5541893","0.5510373","0.5475361","0.5458768","0.5431414","0.5431039","0.54197127","0.5403238","0.53833544","0.538239","0.5359681","0.53353417","0.5308439","0.5272813","0.5271014","0.52697825","0.5251833","0.520326","0.5191881","0.5185377","0.5178261","0.5128098","0.5123116","0.51197296","0.509992","0.5092146","0.50906557","0.50748193","0.5047478","0.5046639","0.5036934","0.5032319","0.50310427","0.5029633","0.50267845","0.50264907","0.5023294","0.5010016","0.49933589","0.4992844","0.49908352","0.49883348","0.4976296","0.49760047","0.49756908","0.4968512","0.49646524","0.49606037","0.49573767","0.49561107","0.4930119","0.49222642","0.4921195","0.49189135","0.48993447","0.48923916","0.48876217","0.48822835","0.4880423","0.4879754","0.48702094","0.48692203","0.486906","0.48660547","0.48631266","0.4859658","0.48588184","0.48570377","0.48532522","0.4849662","0.48427576","0.4840842","0.48401237","0.4833268"],"string":"[\n \"0.7412921\",\n \"0.7408514\",\n \"0.6695499\",\n \"0.6539618\",\n \"0.65338993\",\n \"0.64012855\",\n \"0.6347697\",\n \"0.62790763\",\n \"0.625587\",\n \"0.61357576\",\n \"0.60827684\",\n \"0.60016644\",\n \"0.5909071\",\n \"0.5871183\",\n \"0.5864181\",\n \"0.58204234\",\n \"0.57807314\",\n \"0.5719914\",\n \"0.57073295\",\n \"0.5690754\",\n \"0.56851184\",\n \"0.5678762\",\n \"0.56695163\",\n \"0.5629338\",\n \"0.56254816\",\n \"0.5602676\",\n \"0.5541893\",\n \"0.5510373\",\n \"0.5475361\",\n \"0.5458768\",\n \"0.5431414\",\n \"0.5431039\",\n \"0.54197127\",\n \"0.5403238\",\n \"0.53833544\",\n \"0.538239\",\n \"0.5359681\",\n \"0.53353417\",\n \"0.5308439\",\n \"0.5272813\",\n \"0.5271014\",\n \"0.52697825\",\n \"0.5251833\",\n \"0.520326\",\n \"0.5191881\",\n \"0.5185377\",\n \"0.5178261\",\n \"0.5128098\",\n \"0.5123116\",\n \"0.51197296\",\n \"0.509992\",\n \"0.5092146\",\n \"0.50906557\",\n \"0.50748193\",\n \"0.5047478\",\n \"0.5046639\",\n \"0.5036934\",\n \"0.5032319\",\n \"0.50310427\",\n \"0.5029633\",\n \"0.50267845\",\n \"0.50264907\",\n \"0.5023294\",\n \"0.5010016\",\n \"0.49933589\",\n \"0.4992844\",\n \"0.49908352\",\n \"0.49883348\",\n \"0.4976296\",\n \"0.49760047\",\n \"0.49756908\",\n \"0.4968512\",\n \"0.49646524\",\n \"0.49606037\",\n \"0.49573767\",\n \"0.49561107\",\n \"0.4930119\",\n \"0.49222642\",\n \"0.4921195\",\n \"0.49189135\",\n \"0.48993447\",\n \"0.48923916\",\n \"0.48876217\",\n \"0.48822835\",\n \"0.4880423\",\n \"0.4879754\",\n \"0.48702094\",\n \"0.48692203\",\n \"0.486906\",\n \"0.48660547\",\n \"0.48631266\",\n \"0.4859658\",\n \"0.48588184\",\n \"0.48570377\",\n \"0.48532522\",\n \"0.4849662\",\n \"0.48427576\",\n \"0.4840842\",\n \"0.48401237\",\n \"0.4833268\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.74909633"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20181,"cells":{"query":{"kind":"string","value":"builds urls for the directions and distance matrix apis"},"document":{"kind":"string","value":"def build_url(start, end, transit_mode):\n transit = \"\"\n traffic = \"best_guess\"\n depart = \"now\"\n if transit_mode:\n transit = transit_mode\n direc_url = g_api_base_url + dir_url + \"origin=\" + start + \"&destination=\" + end + trans_url \\\n + transit + goog_dir_key\n dist_url = g_api_base_url + dis_url + units_i + or_dis_url + start + des_url + end + trans_url \\\n + transit + traffic_url + traffic + depart_url + depart + goog_dis_key\n direc_url = direc_url.replace(\" \",\"+\")\n print(\"directions :\"+ direc_url)\n dist_url = dist_url.replace(\" \",\"+\")\n return direc_url, dist_url"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_url(_origin_details, travel_start_date, travel_start_time, destination_list):\n prefix = 'https://timetable.search.ch/api/route.json?one_to_many=1'\n\n origin_body = f'&from={_origin_details}&date={travel_start_date}&time={travel_start_time}'\n\n # Build iteratively with necessary syntax between destinations\n destination_body = ''\n for i, dest in enumerate(destination_list):\n destination_body = f'{destination_body}&to[{i}]={dest}'\n\n return f'{prefix}{origin_body}{destination_body}'","def build_url(ori_lon, ori_lat, des_lon, des_lat, year, month, day, hour, minute, args={}):\n options = dict()\n with open(option_file, 'r', newline='') as file:\n # Read the options file\n for line in file:\n if line[0] == '#': # if the first character of a line is '#' skip it\n continue\n splited_line = line.rstrip().split(':')\n if len(splited_line) < 2: # if it is a line with no ':'\n continue\n options[splited_line[0]] = splited_line[1]\n base_URL = 'localhost:' + port + '/otp/routers/default/plan'\n fromPlace = ori_lon + ',' + ori_lat\n toPlace = des_lon + ',' + des_lat\n date = year + '/' + month + '/' + day\n time = hour + ':' + minute + ':00'\n\n url = 'http://' + base_URL + '?fromPlace=' + fromPlace + '&toPlace=' + toPlace + '&date=' + date + '&time=' + time\n for option_name in options.keys():\n option = options[option_name]\n url += '&' + option_name + '=' + option\n if not 'mode' in url:\n url += '&mode=TRANSIT,WALK'\n for key in args.keys():\n url+= '&' + key + '=' + args[key]\n\n return url","def urlGenerator(self):\n \n # VERMONT #\n baseurl = 'https://www.vermontjudiciary.org'\n path = '/opinions-decisions'\n # from date\n param1 = 'facet_from_date=01/01'\n # to date\n param2 = 'facet_to_date=01/01/'\n # division\n param3 = 'f%5B0%5D=court_division_opinions_library%3A'\n # search by text\n param4 = 'search_api_fulltext='\n # page\n param5 = 'page='\n # generate list of URL\n listURL = []\n \n # list of divisions\n vt_court_division = {\"civil\": \"1\", \"supreme court\": \"7\", \"environmental\": \"3\", \"family\": \"4\", \"criminal\": \"2\"}\n # inputs\n from_year = 2000\n to_year = 2017\n endPages = 75 #0-74\n startPages = 0\n # make change to pull data from different division by changing division name below to any of the division in vt_court_vivision dict\n division = vt_court_division[\"environmental\"]\n # url generating\n for i in range(startPages, endPages):\n build_url = baseurl + path + '?' + param1 + str(from_year) + \"&\" + param2 + str(to_year) + \"&\" + param3 + division + param4 + \"&\" + param5 + str(i) + \"\"\n # append url to listUrl\n listURL.append(build_url)\n i += 1\n \n # return full list of URLs\n return listURL","def gen_url(self):\n self.url = \"https://www.cubedb.net/?rank=3&title={}&time={}&scramble=\".format(self.name_of_solve, self.time_solve)\n for move in self.scramble.split():\n if \"\\'\" in move:\n move.replace(\"\\'\", \"-\")\n self.url += \"{}_\".format(move)\n self.url += \"&alg=\"\n count = 0\n for move in self.solve_stats:\n if self.comms_unparsed_bool:\n if self.comms_unparsed_bool:\n if move[\"comment\"] != \"\":\n if \"mistake\" in move[\"comment\"]:\n move[\"comment\"] = \"{}%0A//{}\".format(move[\"comment\"].split(\"mistake\")[0],\n \"mistake from here\")\n if \"#\" in move[\"comment\"]:\n piece = move[\"comment\"].split(\"#\")[0]\n move[\"comment\"] = move[\"comment\"].split(\"#\")[1]\n if self.url.rfind(\"%0A\") != -1:\n alg = self.url[self.url.rfind(\"%0A\") + 3:]\n self.url = self.url[:self.url.rfind(\"%0A\") + 3] + \"%0A//{}%0A\".format(piece) + alg\n else:\n alg = self.url[self.url.rfind(\"=\") + 1:]\n self.url = self.url[:self.url.rfind(\"=\") + 1] + \"%0A//{}%0A\".format(piece) + alg\n self.url += self.comms_unparsed[count]\n count += 1\n self.url += \"// {} %0A\".format(move[\"comment\"])\n\n\n else:\n if \"move\" in move:\n if move[\"move\"] != \"\":\n if \"\\'\" in move[\"move\"]:\n move[\"move\"].replace(\"\\'\", \"-\")\n self.url += \"{}_\".format(move[\"move\"])\n if move[\"comment\"] != \"\":\n if \"mistake\" in move[\"comment\"]:\n move[\"comment\"] = \"{}%0A//{}\".format(move[\"comment\"].split(\"mistake\")[0], \"mistake from here\")\n if \"#\" in move[\"comment\"]:\n piece = move[\"comment\"].split(\"#\")[0]\n move[\"comment\"] = move[\"comment\"].split(\"#\")[1]\n if self.url.rfind(\"%0A\") != -1:\n alg = self.url[self.url.rfind(\"%0A\") + 3:]\n self.url = self.url[:self.url.rfind(\"%0A\") + 3] + \"//{}%0A\".format(piece) + alg\n else:\n alg = self.url[self.url.rfind(\"=\") + 1:]\n self.url = self.url[:self.url.rfind(\"=\") + 1] + \"//{}%0A\".format(piece) + alg\n\n self.url += \"// {} %0A\".format(move[\"comment\"])\n else:\n self.url += \"// {} %0A\".format(move[\"comment\"])","def getURLs():","def _make_url(self):\n ...","def build_url(vehicle, coordinates, format=\"json\", geometryformat=\"isoz\"):\n load = vehicle.load if vehicle.load > -1.0 else 0\n params = {\n \"format\": format,\n \"height\": vehicle.height,\n \"length\": vehicle.length,\n \"stops\": coordinates,\n \"load\": load,\n \"geometryformat\": geometryformat,\n \"lang\": \"nb-no\",\n }\n\n return '?'.join([ROUTE_URL_BASE, urlencode(params)])","def generate_url(self):\n if self.has_marker:\n marker_param = f'mlat={self.mlat}&mlng={self.mlng}&'\n else:\n marker_param = ''\n if self.start:\n start_param = 'start=true&'\n else:\n start_param = ''\n url = f'{MapController.MAP_URL}?{start_param}clat={self.clat}&clng={self.clng}&{marker_param}zoom={self.zoom}'\n return url","def make_url(site,node,instrument,method,stream,API_USERNAME,API_TOKEN):\n\n SENSOR_BASE_URL = 'https://ooinet.oceanobservatories.org/api/m2m/12576/sensor/inv/'\n VOCAB_BASE_URL = 'https://ooinet.oceanobservatories.org/api/m2m/12586/vocab/inv'\n meta_request_url ='/'.join((VOCAB_BASE_URL,site,node,instrument)) # Python wizard best\n data_request_url ='/'.join((SENSOR_BASE_URL,site,node,instrument,method,stream))\n\n # Retrieve vocabulary information for a given instrument\n r = requests.get(meta_request_url, auth=(API_USERNAME, API_TOKEN))\n meta_data = r.json()\n\n return (data_request_url,meta_data)","def routes():\n import urllib.request, urllib.parse, urllib.error\n output = []\n for rule in app.url_map.iter_rules():\n options = {}\n for arg in rule.arguments:\n options[arg] = \"[{0}]\".format(arg)\n methods = ','.join(rule.methods)\n url = url_for(rule.endpoint, **options)\n line = urllib.parse.unquote(\"{:50s} {:20s} {}\".format(rule.endpoint, methods, url))\n output.append(line)\n for line in sorted(output):\n print (line)","def drivingdistance(origin, destination, APIkey):\n\n lat1, lon1 = origin\n lat2, lon2 = destination\n\n gm_url = ('https://maps.googleapis.com/maps/api/directions/xml?' +\n 'origin='+str(lat1) + ',' + str(lon1) +\n '&destination=' + str(lat2) + ','+str(lon2) +\n '&key='+APIkey)\n\n return gm_url","def _create_api_ulr_list(self) -> List[str]:\n api = Setup.openweather_api\n now = int(time.time())\n urls_list = []\n\n for lat, lon in self.locations:\n urls_list.append(\n f\"https://api.openweathermap.org/data/2.5/onecall?\"\n f\"lat={lat}&lon={lon}&exclude=hourly,minutely,\"\n f\"alerts&units=metric&appid={api}\"\n )\n\n for days in range(1, 6):\n date_time = now - 86400 * days\n urls_list.append(\n f\"http://api.openweathermap.org/data/2.5/onecall/\"\n f\"timemachine?lat={lat}&lon={lon}&dt={date_time}\"\n f\"&units=metric&appid={api}\"\n )\n\n return urls_list","def uri(self):\n if not self.parallel:\n if len(self.WMO) <= 5: # todo: This max WMO number should be parameterized somewhere else\n # Retrieve all WMOs in a single request\n return [self.get_url()]\n else:\n # Retrieve one WMO by URL sequentially (same behaviour as localftp and argovis)\n urls = []\n for wmo in self.WMO:\n urls.append(\n Fetch_wmo(\n WMO=wmo, CYC=self.CYC, ds=self.dataset_id, parallel=False\n ).get_url()\n )\n return urls\n else:\n self.Chunker = Chunker(\n {\"wmo\": self.WMO}, chunks=self.chunks, chunksize=self.chunks_maxsize\n )\n wmo_grps = self.Chunker.fit_transform()\n # self.chunks = C.chunks\n urls = []\n for wmos in wmo_grps:\n urls.append(\n Fetch_wmo(\n WMO=wmos, CYC=self.CYC, ds=self.dataset_id, parallel=False\n ).get_url()\n )\n return urls","def test_url_construction(self):\n\n a = api.InvenTreeAPI(\"http://localhost:1234\", connect=False)\n\n tests = {\n 'part': 'http://localhost:1234/api/part/',\n '/part': 'http://localhost:1234/api/part/',\n '/part/': 'http://localhost:1234/api/part/',\n 'order/so/shipment': 'http://localhost:1234/api/order/so/shipment/',\n }\n\n for endpoint, url in tests.items():\n self.assertEqual(a.constructApiUrl(endpoint), url)","def __get_urls(self):\n self.__valid_servers = {\n \"qa\": {\n \"server_url\": \"https://qa.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://qa.api.deepaffex.ai:9080\"\n },\n \"dev\": {\n \"server_url\": \"https://dev.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://dev.api.deepaffex.ai:9080\"\n },\n \"demo\": {\n \"server_url\": \"https://demo.api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://demo.api.deepaffex.ai:9080\"\n },\n \"prod\": {\n \"server_url\": \"https://api.deepaffex.ai:9443\",\n \"websocket_url\": \"wss://api.deepaffex.ai:9080\"\n },\n \"prod-cn\": {\n \"server_url\": \"https://api.deepaffex.cn:9443\",\n \"websocket_url\": \"wss://api.deepaffex.cn:9080\"\n },\n \"demo-cn\": {\n \"server_url\": \"https://demo.api.deepaffex.cn:9443\",\n \"websocket_url\": \"wss://demo.api.deepaffex.cn:9080\"\n }\n }\n try:\n self.server_url = self.__valid_servers[self.server][\"server_url\"]\n self.websocket_url = self.__valid_servers[self.server][\"websocket_url\"]\n except KeyError:\n raise KeyError(\"Invalid server ID given\")","def get_url(self, source):\n if source == 'nomads':\n if self.model == 'rap':\n base = 'https://nomads.ncep.noaa.gov/pub/data/nccf/com/rap/prod/'\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\n else:\n base = 'https://nomads.ncep.noaa.gov/pub/data/nccf/com/hrrr/prod/'\n if self.model == 'hrrr':\n path = f\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\"\n elif self.model == 'hrrrak':\n path = f\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\"\n elif source == 'aws':\n if self.model == 'rap':\n base = 'https://noaa-rap-pds.s3.amazonaws.com/'\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\n else:\n base = 'https://noaa-hrrr-bdp-pds.s3.amazonaws.com/'\n if self.model == 'hrrr':\n path = f\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\"\n elif self.model == 'hrrrak':\n path = f\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\"\n elif source == 'google':\n if self.model == 'rap':\n base = 'https://storage.googleapis.com/rapid-refresh/'\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\n else:\n base = 'https://storage.googleapis.com/high-resolution-rapid-refresh/'\n if self.model == 'hrrr':\n path = f\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\"\n elif self.model == 'hrrrak':\n path = f\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\"\n elif source == 'azure':\n if self.model == 'rap':\n base = 'https://noaarap.blob.core.windows.net/rap'\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\n else:\n base = 'https://noaahrrr.blob.core.windows.net/hrrr/'\n if self.model == 'hrrr':\n path = f\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\"\n elif self.model == 'hrrrak':\n path = f\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\"\n elif source.startswith('pando'):\n if source[-1] == '2':\n gateway = 2\n else:\n gateway = 1\n if self.model == 'rap':\n return None # No RAP data on Pando\n else:\n base = f'https://pando-rgw0{gateway}.chpc.utah.edu/'\n path = f\"{self.model}/{self.field}/{self.date:%Y%m%d}/{self.model}.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\"\n \n return base+path","def calc_url(self):\n place = self._get_first_place()[0]\n path = \"\"\n # First see if we are in or near Sweden or Denmark\n # Change country to upper case\n location = get_main_location(self.database, place)\n country = location.get(PlaceType.COUNTRY, '').upper().strip()\n country_given = (country in MAP_NAMES_SWEDEN or \\\n country in MAP_NAMES_DENMARK) and (country != \"\")\n # if no country given, check if we might be in the vicinity defined by\n # 54 33' 0\" < lat < 66 9' 0\", 54.55 and 69.05\n # 8 3' 0\" < long < 24 9' 0\", 8.05 and 24.15 \n latitude, longitude = self._lat_lon(place)\n if latitude is None or longitude is None:\n coord_ok = False\n else:\n latitude = float(latitude) \n longitude = float(longitude)\n # Check if coordinates are inside Sweden and Denmark\n if (54.55 < latitude < 69.05) and (8.05 < longitude < 24.15):\n coord_ok = True\n else:\n msg2 = _(\"Latitude not within '54.55' to '69.05'\\n\") + \\\n _(\"Longitude not within '8.05' to '24.15'\")\n WarningDialog(_(\"Eniro map not available\"), msg2 )\n return\n\n if coord_ok:\n place_title = _build_title(self.database, place)\n place_city = _build_city(self.database, place)\n x_coord, y_coord = self._lat_lon(place, format=\"RT90\")\n # Set zoom level to 5 if Sweden/Denmark, others 3\n zoom = 5\n if not country_given:\n zoom = 3\n path = \"http://www.eniro.se/partner.fcgi?pis=1&x=%s&y=%s\" \\\n \"&zoom_level=%i&map_size=0&title=%s&city=%s&partner=gramps\"\n # Note x and y are swapped!\n path = path % (y_coord , x_coord, zoom, place_title, place_city)\n self.url = path.replace(\" \",\"%20\")\n return\n\n place_area = _build_area(self.database, place)\n if country_given and place_area:\n if country in MAP_NAMES_SWEDEN:\n path = \"http://kartor.eniro.se/query?&what=map_adr&mop=aq\" \\\n \"&geo_area=%s&partner=gramps\"\n path = path % (place_area)\n self.url = path.replace(\" \",\"%20\")\n return\n else:\n WarningDialog(_(\"Eniro map not available\"), \\\n _(\"Coordinates needed in Denmark\") )\n self.url = \"\"\n return\n\n WarningDialog(_(\"Eniro map not available\"), \n _(\"Latitude and longitude,\\n\" \\\n \"or street and city needed\") )\n return","def getDataUrls(self):\n sub1 = self.id[0:3]\n sub2 = self.id[3:6]\n sub3 = self.id[6:9]\n self.xml = \"%s/static/model/%s/%s/%s/%s.xml\" % (serverString, sub1, sub2, sub3, self.id)\n self.image = \"%s/static/image/%s/%s/%s/%s_lrg.png\" % (serverString, sub1, sub2, sub3, self.id)\n self.thumb = \"%s/static/thumb/%s/%s/%s/%s.png\" % (serverString, sub1, sub2, sub3, self.id)","def build_urls(self, listings_per_page=20, pages_per_location=15):\r\n url_list = []\r\n for i in range(pages_per_location):\r\n offset = listings_per_page * i\r\n url_pagination = self.link + f'&items_offset={offset}'\r\n url_list.append(url_pagination)\r\n self.url_list = url_list","def build_url(self):\n return self.data_url.format(latitude=self.latitude, longitude=self.longitude)","def _generate_urls(base_url, mbid):\n for level in LEVELS:\n yield base_url + mbid + level","def url_shortner(self):","def create_web_output_paths() -> None:\n create_path_and_index(\"\")\n create_path_and_index(\"photos/\")\n create_path_and_index(\"video/\")\n create_path_and_index(\"references/\")\n create_path_and_index(\"names/\")\n create_path_and_index(\"art/\")\n create_path_and_index(\"morphology/\")\n create_path_and_index(\"maps/\")\n create_path_and_index(\"images/\")\n create_path_and_index(\"images/flag-icon-css/\")\n create_path_and_index(\"images/flag-icon-css/css/\")\n create_path_and_index(\"images/flag-icon-css/flags/\")\n create_path_and_index(\"images/flag-icon-css/flags/4x3/\")\n create_path_and_index(\"locations/\")\n create_path_and_index(\"locations/keys/\")\n create_path_and_index(\"js/\")\n create_path_and_index(\"sizes/\")\n create_path_and_index(\"handedness/\")","def _url_builder(url_root,api_key,path,params):\n params['api_key'] = api_key\n url_end = urlencode(params)\n url = \"%s%s%s\" % (url_root,path,url_end)\n return url","def Url(self) -> str:","def test_urls(self):\n self.base_check_request(\"get\", \"/\")\n self.base_check_request(\"get\", \"apartments/\")\n self.base_check_request(\"get\", \"complexes/\")\n self.base_check_request(\"get\", \"locations/\")\n self.base_check_request(\"get\", \"companies/\")\n self.base_check_request(\"get\", \"companies-types/\")\n\n self.base_check_request(\"get\", \"count/apartments/\")\n self.base_check_request(\"get\", \"count/complexes/\")\n\n self.base_check_request(\"get\", \"search-forms/apartments/\")\n self.base_check_request(\"get\", \"search-forms/complexes/\")\n self.base_check_request(\"get\", \"search-forms/main/\")\n\n self.base_check_request(\"get\", \"autocomplete/companies/\")\n self.base_check_request(\"get\", \"autocomplete/complexes/\")\n self.base_check_request(\"get\", \"autocomplete/locations/\")\n\n self.base_check_request(\"get\", \"apartments_for_maps/?count=1&fields=lat,lon\")\n # self.base_check_request(\"get\", \"reserve/\")\n # self.base_check_request(\"get\", \"complain/\")\n # self.base_check_request(\"post\", \"apartment-complain/\")\n # self.base_check_request(\"post\", \"order-apartment/\")","def getSDDCT0routes(proxy_url, session_token):\n t0_routes_json = get_sddc_t0_routes_json(proxy_url, session_token)\n t0_routes = {}\n if 'results' in t0_routes_json:\n pass\n else:\n print(\"No results. Something went wrong - please check your syntax and try again.\")\n sys.exit(1)\n\n if t0_routes_json == None:\n print(\"API Error\")\n sys.exit(1)\n elif len(t0_routes_json['results']) == 1:\n t0_routes = t0_routes_json['results'][0]['route_entries']\n elif len(t0_routes_json['results']) >1:\n t0_routes0 = t0_routes_json['results'][0]['route_entries']\n t0_routes1 = t0_routes_json['results'][1]['route_entries']\n t0_routes = t0_routes0 + t0_routes1\n\n df = pd.DataFrame(t0_routes)\n df.drop(['lr_component_id', 'lr_component_type'], axis=1, inplace=True)\n df.drop_duplicates(inplace = True)\n print('T0 Routes')\n print('Route Type Legend:')\n print('t0c - Tier-0 Connected\\nt0s - Tier-0 Static\\nb - BGP\\nt0n - Tier-0 NAT\\nt1s - Tier-1 Static\\nt1c - Tier-1 Connected\\nisr: Inter-SR')\n print()\n print(df.sort_values(by=[ 'route_type', 'network'], ascending=True).to_string())\n # route_table = PrettyTable(['Route Type', 'Network', 'Admin Distance', 'Next Hop'])\n # for routes in t0_routes:\n # route_table.add_row([routes['route_type'],routes['network'],routes['admin_distance'],routes['next_hop']])\n # print (route_table.get_string(sort_key = operator.itemgetter(1,0), sortby = \"Network\", reversesort=True))","def ajax_solve():\n\n # The possible errors and their human-readable messages\n ERRORS = {\n 403: \"Google Directions could not find a path\",\n 404: \"Google Directions did not send response\",\n 405: \"You did not specify a start\",\n 406: \"You need to specify at least two waypoints\",\n 407: \"You did not specify a valid algorithm\",\n 408: \"Internal Algorithm Error\",\n\n }\n\n\n def to_tuple(waypoint):\n \"\"\"\n Converts LatLng dicts to tuples.\n\n :param waypoint: A waypoint as string, tuple or LatLng dict\n :return: waypoint, if waypoint is string or tuple,\n a tuple of the lat and lng values, if dict\n\n \"\"\"\n if isinstance(waypoint, dict):\n return (waypoint[\"lat\"], waypoint[\"lng\"])\n else:\n return waypoint\n\n def to_dict(waypoint):\n \"\"\"\n Converts to tuples to LatLng dicts.\n\n :param waypoint: A waypoint as string or tuple\n :return: waypoint, if waypoint is string or tuple,\n a LatNg dict, if tuple\n \"\"\"\n if isinstance(waypoint, tuple):\n return {\"lat\": waypoint[0], \"lng\": waypoint[1]}\n else:\n return waypoint\n\n\n\n # Get the arguments\n json = request.args\n\n # Check that a start point is supplied\n start = json.get(\"origin\")\n if not start:\n return jsonify(status=406, msg=ERRORS[405])\n\n # Convert to tuple if necessary\n # This is needed to store waypoints as keys in a dict\n start = to_tuple(start)\n\n\n\n waypoints = json.getlist(\"waypoints[]\")\n if not waypoints:\n return jsonify(status=406, msg=ERRORS[406])\n\n # We need to have at least two points for a path\n if len(waypoints) < 2:\n return jsonify(status=406, msg=ERRORS[406])\n\n # Convert to tuple if necessary\n # This is needed to store waypoints as keys in a dict\n waypoints = map(to_tuple, waypoints)\n\n # Get the algorithm\n algorithm = algorithms[json[\"algo\"]]\n if not algorithm:\n return jsonify(status=407, msg=ERRORS[407])\n\n # Get the options\n options = {}\n for option in algorithm.options():\n options[option] = float(json.get(\"options[%s]\" % option))\n\n try:\n distances = matrix.create(waypoints)\n except BaseException as e:\n logging.warning(\"Exception %s while creating matrix for %s\" % (e, waypoints))\n return jsonify(status=404, msg=ERRORS[404])\n else:\n if distances:\n\n try:\n # Call the algorithm\n l, path = algorithm.solve(start, distances, **options)\n except BaseException as e:\n logging.warning(\"Exception %s while executing %s with %s\" % (e, algorithm.name, options))\n return jsonify(status=408, msg=ERRORS[408])\n else:\n # Pack result\n result = {\n \"status\": 200,\n \"length\": l,\n \"start\": start,\n \"algo\": json[\"algo\"],\n \"path\": map(to_dict, path),\n \"msg\": \"SUCCESS\"\n }\n\n # Return the result\n return jsonify(result)\n else:\n return jsonify(status=403, msg=ERRORS[403])","def get_urls(self):\n \n url_strings = dict()\n \n \n for platform in constants.PLATFORMS:\n download_path = reverse('download-installer', kwargs={\n 'build_id': self.build_id,\n 'platform': platform,\n })\n \n url_strings[platform] = settings.BASE_URL.rstrip('/') + download_path\n \n \n return url_strings","def get_urls(self, **kwargs):\n pass # pragma: no cover","def url(self):\n ...","async def api():\n return {\n \"links\": {\n \"datasets\": \"/datasets\",\n \"natural_earth_feature\": \"/natural_earth_feature\",\n \"viewport\": \"/viewport\"\n }\n }","def roadSegments(locations, API_key=\"Avah46_M-gfFeQ3P1w09Qq1ElAV9ZEHFDm9b8JRCRa8qPP5uVn21hDqAPVJgV4i_\"): \n \n # Base URL\n uri = 'http://dev.virtualearth.net/' # Resource URL \n path = 'REST/v1/Routes?'\n \n \n # URL Parameters\n params = { 'wayPoint.0' : locations[0]+',Singapore',\n 'wayPoint.1' : locations[1]+',Singapore',\n 'routeAttributes':'routePath',\n 'key' : API_Key} # by default 'optimize' : 'time'} # this is by default\n \n url = uri+path\n\n results = requests.get(\n url,\n params = params\n ).json()# ['resourceSets']\n\n # Retrieving values\n statusCode = results['statusCode']\n if statusCode == 200:\n # print(statusCode)\n\n # TODO review the exceptions and modify these basic exception handlings\n try:\n travelDistance = results['resourceSets'][0]['resources'][0]['travelDistance']\n except:\n travelDistance = 0\n try:\n travelDuration = results['resourceSets'][0]['resources'][0]['travelDuration']\n except:\n travelDuration = 0\n try:\n travelDurationTraffic = results['resourceSets'][0]['resources'][0]['travelDurationTraffic']\n except:\n travelDurationTraffic = 0\n\n try:\n numberSegments = len(results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\n ['itineraryItems'])\n except:\n numberSegments = 0\n try:\n itineraryItems = results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\n ['itineraryItems']\n except:\n itineraryItems = 'No items'\n\n pathCoord = results['resourceSets'][0]['resources'][0]['routePath']['line']['coordinates']\n\n roadName = []\n travelDistances = []\n travelDurations = []\n maneuverType = []\n\n for seg in itineraryItems:\n for i in range(len(seg['details'])):\n # print(i)\n try:\n roadName.append(seg['details'][i]['names'])\n except:\n roadName.append(0)\n try:\n travelDistances.append(seg['travelDistance'])\n except:\n travelDistances.append(0)\n\n try:\n travelDurations.append(seg['travelDuration'])\n except:\n travelDurations.append(0)\n try:\n maneuverType.append(seg['details'][i]['maneuverType'])\n except:\n maneuverType.append(0)\n\n\n return statusCode,travelDistance,travelDuration,travelDurationTraffic,numberSegments,roadName, \\\n travelDistances, travelDurations, maneuverType, pathCoord\n\n else:\n print(\"Unsuccessful route calculation.\")","def getSDDCT0staticroutes(proxy_url,session_token):\n t0_static_routes_json = get_sddc_t0_static_routes_json(proxy_url, session_token)\n if t0_static_routes_json == None:\n print(\"API Error\")\n sys.exit(1)\n if 'results' in t0_static_routes_json:\n t0_static_routes = t0_static_routes_json['results']\n else:\n print(\"No results. Something went wrong - please check your syntax and try again.\")\n sys.exit(1)\n route_table = PrettyTable(['Display Name', 'Network', 'Admin Distance', 'Next Hop'])\n for routes in t0_static_routes:\n route_table.add_row([routes['display_name'],routes['network'],routes['next_hops'][0]['admin_distance'],routes['next_hops'][0]['ip_address']])\n print (route_table.get_string(sort_key = operator.itemgetter(1,0), sortby = \"Network\", reversesort=True))","def home():\n return(\n f\"Available Routes: <br/>\"\n\n f\"For Precipitation: /api/v1.0/precipitation<br/>\"\n f\"Returns Jsonify dictionary of dates and Precepitation<br/><br/>\"\n\n f\"For list of Stations: /api/v1.0/stations<br/>\"\n f\"Returns Jasonify list of stations <br/><br/>\"\n\n f\"For last year temperatures: /api/v1.0/tobs<br/>\"\n f\"Returns Jsonify dictionary of Temperature Observations for last year<br/><br/>\"\n\n f\"Temperature result from the date in format (yyyy-mm-dd): /api/v1.0/yyyy-mm-dd<br/>\"\n f\"Returns an Average, Max, and Min temperatures from given start date of dataset<br/><br/>\"\n\n f\"Temperature result from start date to end date in format (yyyy-mm-dd): /api/v1.0/yyyy-mm-dd/yyyy-mm-dd<br/>\"\n f\"Returns an Average, Max, and Min temperatures for a given date range\"\n\n )","def _build_directions(self):\n d = {'start': self.get_start(), 'end': self.get_end(), 'duration': self.get_duration(),\n 'mode': self.get_primary_mode(), 'price_range': self.get_price_range(), 'legs': self.get_legs(),\n 'start_location': self.get_start_location(), 'end_location': self.get_end_location()}\n self.set_directions(d)","def build_url(main_url, url_params):\n return main_url + \"/\" + \"/\".join(url_params)","def visualize(g):\n url = \"http://www.gcmap.com/mapui?P=\"\n routes = []\n \n for key in g.city_dict:\n for flight in g.city_dict[key].get_flights_out():\n route = (g.city_dict[key].get_code(), flight[0])\n if(route not in routes):\n routes.append(route)\n \n for flight in routes:\n url = url + flight[0] + \"-\" + flight[1]\n url = url + \",+\"\n \n url = url[:-2]\n return url","def _generate_url(action, query_params=None):\r\n if query_params:\r\n query_params = urllib.parse.urlencode(query_params)\r\n action = f\"{action}?{query_params}\"\r\n \r\n\r\n url = urllib.parse.urljoin(api_url, action)\r\n\r\n return url","def next_xml_url(query_url, query_points, routers):\n index = 4\n last_query_point = \"\"\n query = str(query_points[0])\n if query == \"stats\":\n return \"stats\"\n elif query == \"agencyList\":\n return query_url + \"agencyList\"\n\n for i in range(index, len(routers), 1):\n try:\n last_query_point = str(query_points[i - index])\n except:\n pass\n query_url += last_query_point + str(routers[i])\n\n return query_url","def url(vmanage_host,vmanage_port,api):\r\n \"\"\" function to get the url provide api endpoint \"\"\"\r\n \r\n return f\"https://{vmanage_host}:{vmanage_port}{api}\"","def __create_routes__(self):\n self.app.add_url_rule('/', 'main_page', self.main_page)\n self.app.add_url_rule('/day', 'day', self.get_current_iteration, methods=['GET'])\n self.app.add_url_rule('/traders', 'traders', self.register_trader, methods=['POST'])\n self.app.add_url_rule('/traders/<id>', 'trader', self.get_trader_state, methods=['GET'])\n self.app.add_url_rule('/stock/price', 'price', self.get_stock_price, methods=['GET'])\n self.app.add_url_rule('/stock/history', 'history', self.get_stock_price_history, methods=['GET'])\n self.app.add_url_rule('/stock/buy', 'buy', self.place_buy_order, methods=['POST'])\n self.app.add_url_rule('/stock/sell', 'sell', self.place_sell_order, methods=['POST'])\n self.app.add_url_rule('/simulation/step', 'step', self.market_session_step, methods=['POST'])\n self.app.add_url_rule('/simulation/run', 'run', self.run_simulation, methods=['POST'])","def get_urls(self):\n info = self.model._meta.app_label, self.model._meta.model_name\n\n return super().get_urls() + [\n path(\"ajax\", self.callback, name=\"%s_%s_ajax\" % info),\n path(\"layer\", self.get_layer, name=\"%s_%s_layer\" % info)\n ]","def list_routes():\n import urllib\n output = []\n for rule in app.url_map.iter_rules():\n options = {}\n for arg in rule.arguments:\n options[arg] = \"[{0}]\".format(arg)\n\n methods = ','.join(rule.methods)\n url = url_for(rule.endpoint, **options)\n line = urllib.parse.unquote(\n \"{:35s} {:35s} {}\".format(\n rule.endpoint,\n methods,\n url\n )\n )\n output.append(line)\n\n for line in sorted(output):\n print(line)","def _create_request_url():\n url = 'http'\n if _config['save']:\n url += 's'\n url += '://{}:{}/move'.format(_config['ip'], _config['port'])\n return url","def construct_url(self):\n path = [self.path]\n path.extend([str(x) for x in self.params])\n\n url = self.client.base_url + '/'.join(x for x in path if x)\n query = self.kwargs.get('query')\n\n if query:\n # Dict -> List\n if type(query) is dict:\n query = query.items()\n\n # Remove items with `None` value\n query = [\n (k, v) for (k, v) in query\n if v is not None\n ]\n\n # Encode query, append to URL\n url += '?' + urlencode(query)\n\n return url","def build_links(self):\n xygrid = self.xymap.xygrid\n\n # we must use the xygrid coordinates\n x, y = self.x, self.y\n\n # scan in all directions for links\n for direction, (dx, dy) in MAPSCAN.items():\n\n lx, ly = x + dx, y + dy\n\n if lx in xygrid and ly in xygrid[lx]:\n link = xygrid[lx][ly]\n\n # just because there is a link here, doesn't mean it has a\n # connection in this direction. If so, the `end_node` will be None.\n end_node, weight, steps = link.traverse(REVERSE_DIRECTIONS[direction])\n\n if end_node:\n # the link could be followed to an end node!\n\n self.first_links[direction] = link\n\n # check the actual direction-alias to use, since this may be\n # different than the xygrid cardinal directions. There must be\n # no duplicates out of this node or there will be a\n # multi-match error later!\n first_step_name = steps[0].direction_aliases.get(direction, direction)\n if first_step_name in self.closest_neighbor_names:\n raise MapParserError(\n f\"has more than one outgoing direction '{first_step_name}'. \"\n \"All directions out of a node must be unique.\",\n self,\n )\n self.closest_neighbor_names[first_step_name] = direction\n\n node_index = end_node.node_index\n self.weights[node_index] = weight\n self.links[direction] = end_node\n # this is useful for map building later - there could be multiple\n # links tied together until getting to the node\n self.xy_steps_to_node[direction] = steps\n\n # used for building the shortest path. Note that we store the\n # aliased link directions here, for quick display by the\n # shortest-route solver\n shortest_route = self.shortest_route_to_node.get(node_index, (\"\", [], BIGVAL))[\n 2\n ]\n if weight < shortest_route:\n self.shortest_route_to_node[node_index] = (first_step_name, steps, weight)","def test_url_helper_coordinates():\n urlh = URLHelper()\n args = []\n kwargs = {\"coordinates\": \"210.80242917 54.348753\"}\n url = urlh.build_url(*args, **kwargs)\n assert url == \"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/ra=210.802429/dec=54.348753\"","def _generate_url(self, **kwargs):\n path = self.url_path.format(**kwargs)\n return self.poolbot.generate_url(path)","def generate_URLs(county_codes=range(1, 59), city_codes=range(59, 507), county_level=False):\n\tDATA_PATH = \"https://www2.calrecycle.ca.gov/WasteCharacterization/ResidentialStreams?cy={}&lg={}&mt=0&bg=0&mtf=0\"\n\n\tpossible_URLs = []\n\tfor county in county_codes:\n\t if county_level:\n\t possible_URLs.append(DATA_PATH.format(county, county+1000))\n\t else:\n\t for city in city_codes:\n\t possible_URLs.append(DATA_PATH.format(county, city))\n\treturn possible_URLs","def request_url(request):\n \n shot = request.GET['shot']\n path = request.GET['path']\n tree = request.GET['tree']\n\n xml_elmt = '{http://h1svr.anu.edu.au/}dataurlmap'\n lang_attr = {'{http://www.w3.org/XML/1998/namespace}lang': 'en'}\n url_xml = etree.Element(xml_elmt, attrib=lang_attr)\n \n shot_number = etree.SubElement(url_xml, 'shot_number', attrib={})\n shot_number.text = shot\n data_path = etree.SubElement(url_xml, 'path', attrib={})\n data_path.text = path\n data_tree = etree.SubElement(url_xml, 'tree', attrib={})\n data_tree.text = tree\n\n url_processor = URLProcessor(shot=int(shot), tree=tree, path=path)\n url = url_processor.get_url()\n url_el = etree.SubElement(url_xml, 'url', attrib={})\n url_el.text = url\n\n return HttpResponse(etree.tostring(url_xml),\n mimetype='text/xml; charset=utf-8')","def __http_build_url(self, url_path):\n\n return '{}://{}{}'.format(_GOVEE_API_PROTOCOL, _GOVEE_API_HOST, url_path)","def url():\n ...","def _prepare_url(self):\n\n base_url = '{}://{}{}'.format(\n self.client.protocol, self.client.base_url, self.api_path\n )\n url_parts = '/'.join(\n [part for part in self.parameters[constants.RequestConst.PATH]]\n )\n\n if url_parts:\n final_url = '{}/{}'.format(base_url, url_parts)\n else:\n final_url = base_url\n\n if self.method == constants.RequestConst.GET:\n params = self.parameters[constants.RequestConst.QUERY]\n for param, value in params.items():\n if isinstance(value, list):\n params[param] = ','.join(value)\n elif isinstance(value, dict):\n params[param] = ','.join([f'{k}:{v}' for k, v in value])\n\n url_query = '?' + '&'.join([f'{k}={v}' for k, v in params.items()])\n final_url = '{}{}'.format(final_url, url_query)\n\n self.debug.ok('final url', final_url)\n\n return final_url","def get_url(self):\n url = \"https://api.darksky.net/forecast/{}/{},{}?lang={}&units={}\"\\\n .format(str(self.key),\n str(self.lat),\n str(self.lng),\n self.lang,\n self.units)\n addons = \"\"\n if self.exclude is not None:\n addons += \"&exclude=\" + \",\".join(self.exclude)\n if self.extend is not None:\n addons += \"&extend=\" + \",\".join(self.extend)\n\n return url + addons","def build_call(*args):\n call = 'http://atlas.media.mit.edu/'\n for val in args:\n call += str(val) + '/'\n return call","def start_urls(self):\n if self.agency_doc_id or self.dept_doc_id:\n agency_doc_id = self.agency_doc_id\n if isinstance(agency_doc_id, list):\n agency_doc_id = agency_doc_id[0]\n return [\n \"https://detroitmi.gov/documents?{}={}&{}={}\".format(\n self.doc_query_param_dept,\n self.dept_doc_id,\n self.doc_query_param,\n agency_doc_id or \"\",\n )\n ]\n else:\n return [self.get_event_start_url()]","def gen_url(section):\n urls = []\n urls.append('https://ia800500.us.archive.org/22/items/stackexchange/' + section + '.stackexchange.com.7z')\n urls.append('https://ia800500.us.archive.org/22/items/stackexchange/' + section + '.7z')\n return urls","def _generate_url(self, endpoint:str, params:Dict[str, str]=None) -> str:\n if params:\n return f\"{self.BASE_URL}/{self._api_version}{endpoint}?{urlencode(params)}\"\n return f\"{self.BASE_URL}/{self._api_version}{endpoint}\"","def generate_links():\n start_url = 'https://twigserial.wordpress.com/'\n base_url = start_url + 'category/story/'\n tree = etree.HTML(requests.get(start_url).text)\n xpath = './/*/option[@class=\"level-2\"]/text()'\n return [base_url + suffix.strip() for suffix in tree.xpath(xpath)]","def create_url_rules(self):\n\n def p(prefix, route):\n \"\"\"Prefix a route with the URL prefix.\"\"\"\n return f\"{prefix}{route}\"\n\n routes = self.config.routes\n return [\n route(\n \"GET\",\n p(routes[\"communities-prefix\"], routes[\"list\"]),\n self.search\n ),\n route(\n \"POST\",\n p(routes[\"communities-prefix\"], routes[\"list\"]),\n self.create\n ),\n route(\n \"GET\",\n p(routes[\"communities-prefix\"], routes[\"item\"]),\n self.read\n ),\n route(\n \"PUT\",\n p(routes[\"communities-prefix\"], routes[\"item\"]),\n self.update\n ),\n route(\n \"DELETE\",\n p(routes[\"communities-prefix\"], routes[\"item\"]),\n self.delete\n ),\n route(\n \"GET\",\n p(routes[\"user-prefix\"], routes[\"list\"]),\n self.search_user_communities\n ),\n route(\n \"POST\",\n p(routes[\"communities-prefix\"], routes[\"item\"]) + '/rename',\n self.rename\n ),\n route(\n \"GET\",\n p(routes[\"communities-prefix\"], routes[\"item\"]) + '/logo',\n self.read_logo\n ),\n route(\n \"PUT\",\n p(routes[\"communities-prefix\"], routes[\"item\"]) + '/logo',\n self.update_logo\n ),\n route(\n \"DELETE\",\n p(routes[\"communities-prefix\"], routes[\"item\"]) + '/logo',\n self.delete_logo\n ),\n ]","def __get_url(cls, url):\n url = url + AdvertCoordinationAdaptor.BASE_URL_QUERY_STRING\n return url","def create_url(path, controller_ip=DNAC):\n print(\"3\")\n return \"https://%s:%s/api/v1/%s\" % (controller_ip, DNAC_PORT, path)","def build_band_urls(scene, bands):\n return [band_url(scene, band) for band in bands]","def create_query_url(self):\n self.__log('Starting to create the query URL.')\n query_url = self.config['API_URI']\n for key, value in self.options.items():\n if value:\n if query_url == self.config['API_URI']:\n query_url = query_url + str(key) + \"=\" + str(value)\n else:\n query_url = query_url + \"&\" + str(key) + \"=\" + str(value)\n query_url = query_url.replace(' ', '%20')\n self.__log(f'Done creating query url. URL to query: \"{query_url}\"')\n return query_url","def get_url(self):\n # Replace erddapy get_download_url()\n # We need to replace it to better handle http responses with by-passing the _check_url_response\n # https://github.com/ioos/erddapy/blob/fa1f2c15304938cd0aa132946c22b0427fd61c81/erddapy/erddapy.py#L247\n\n # First part of the URL:\n protocol = self.erddap.protocol\n dataset_id = self.erddap.dataset_id\n response = self.erddap.response\n url = f\"{self.erddap.server}/{protocol}/{dataset_id}.{response}?\"\n\n # Add variables to retrieve:\n self.erddap.variables = (\n self._minimal_vlist\n ) # Define the list of variables to retrieve\n variables = self.erddap.variables\n variables = \",\".join(variables)\n url += f\"{variables}\"\n\n # Add constraints:\n self.define_constraints() # Define constraint to select this box of data (affect self.erddap.constraints)\n constraints = self.erddap.constraints\n _constraints = copy.copy(constraints)\n for k, v in _constraints.items():\n if k.startswith(\"time\"):\n _constraints.update({k: parse_dates(v)})\n _constraints = quote_string_constraints(_constraints)\n _constraints = \"\".join([f\"&{k}{v}\" for k, v in _constraints.items()])\n url += f\"{_constraints}\"\n\n # Last part:\n url += '&distinct()&orderBy(\"time,pres\")'\n return url","def build_request_url(symbol, start_date, end_date):\n pass","def _url_map(self):\n return Map([\n Rule('/init', endpoint='init'),\n Rule('/op/<name>', endpoint='op'),\n Rule('/handler/<name>', endpoint='handler'),\n Rule('/hook/<name>', endpoint='hook'),\n Rule('/provider/<name>/<action>', endpoint='provider'),\n Rule('/timer/<name>', endpoint='timer'),\n ])","def get_routes():\n output = [f'{\"S. No.\":6}\\t{\"Endpoint\":50}\\t{\"Method\":8}\\n']\n\n for index, rule in enumerate(app.url_map.iter_rules()):\n for i, method in enumerate(rule.methods):\n output.append(f'{index + 1 if i == 0 else \"\":<6}\\t{rule.rule:50}\\t{method:10}')\n\n try:\n output.append(f'\\n{eval(rule.endpoint).__doc__}\\n')\n except NameError:\n output.append('\\n')\n\n return Response('\\n'.join(output), 200, mimetype='text/plain')","def home():\n return (\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"/api/v1.0/<start>/<end>\"\n \n )","def url(request):\n URL = namedtuple('URL', ['mainnet', 'testnet'])\n\n # For actual trading and market data, the mainnet URL will be used:\n # When developing application, the testnet URL should be used:\n url = URL(mainnet=\"https://api.switcheo.network/v2/\", testnet=\"https://test-api.switcheo.network/v2/\")\n\n def tear_down():\n # clean up here\n pass\n\n request.addfinalizer(tear_down)\n return url","def test_url_helper_radius():\n urlh = URLHelper()\n args = []\n kwargs = {\"radius\": \"0.4d\"}\n url = urlh.build_url(*args, **kwargs)\n assert url == \"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/sr=0.400000d\"","def index():\n g.data['api_version'] = API_VERSION\n g.data['apilib_version'] = API_VERSION\n g.data['oar_version'] = VERSION\n g.data['links'] = []\n #endpoints = ('resources', 'jobs', 'config', 'admission_rules')\n endpoints = ('resources', 'jobs')\n for endpoint in endpoints:\n g.data['links'].append({\n 'rel': 'collection',\n 'href': url_for('%s.index' % endpoint),\n 'title': endpoint,\n })","def makeRouteRequest(latLongs):\n global headersGlobal, routeURL_synchronous # get global variables\n\n key = variables.bingMapsAPIKey # api key\n # construct the URL\n url = routeURL_synchronous + \"wp.0=\" + str(latLongs[0][0]) + \",\" + str(latLongs[0][1]) + \"&wp.1=\" + str(\n latLongs[1][0]) + \",\" + str(latLongs[1][1]) + \"&key=\" + key\n\n request = requests.get(url, headers=headersGlobal) # make the request\n return request # return the request","def buildSFOUrls(jd_start, jd_stop):\n url_list = []\n time_list = ['03z', '09z', '15z', '21z']\n delta = jd_stop-jd_start\n for i in range((delta.days)+1):\n model_file_date = jd_start + timedelta(days=i)\n base_url = ('http://opendap.co-ops.nos.noaa.gov/'\n 'thredds/dodsC/NOAA/SFBOFS/MODELS/')\n val_month, val_year, val_day = '', '', ''\n # Month.\n if model_file_date.month < 10:\n val_month = \"0\" + str(model_file_date.month)\n else:\n val_month = str(model_file_date.month)\n # Year.\n val_year = str(model_file_date.year)\n # Day.\n if model_file_date.day < 10:\n val_day = \"0\" + str(model_file_date.day)\n else:\n val_day = str(model_file_date.day)\n file_name = '/nos.sfbofs.stations.nowcast.'\n file_name += val_year + val_month + val_day\n for t in time_list:\n t_val = '.t' + t + '.nc'\n url_list.append(base_url + val_year + val_month +\n file_name + t_val)\n return url_list","def init_urls(self):\n url = 'http://www.lagou.com/'\n for ip_info in self.col.find(no_cursor_timeout=True):\n ip, port = ip_info['ip'], ip_info['port']\n if ip and port:\n self.urls.append((url, ip, port)) # tuple","def urls(self):\n days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', ]\n url = 'http://www2.nngov.com/newport-news/offenses/%stxt.htm'\n return [url % day for day in days]","def _create_api_ulr_list(self) -> List[str]:\n api = Setup.pickpoint_api\n return [\n f\"https://api.pickpoint.io/v1/reverse/?key={api}&lat={lat}&lon={lon}\"\n f\"&accept-language=en-US\"\n for lat, lon in self.locations\n ]","def urls(self) -> list[str]:\r\n ...","def send_request(origin_addresses, dest_addresses, api):\n def build_address_str(addresses):\n # Build a pipe-separated string of addresses\n address_str = ''\n for i in range(len(addresses) - 1):\n address_str += addresses[i] + '|'\n address_str += addresses[-1]\n return address_str\n\n request = 'https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial'\n origin_address_str = build_address_str(origin_addresses)\n dest_address_str = build_address_str(dest_addresses)\n request = request + '&origins=' + origin_address_str + '&destinations=' + \\\n dest_address_str + '&key=' + api\n jsonResult = urllib.request.urlopen(request).read().decode(\"utf-8\")\n response = json.loads(jsonResult)\n return response","def test_client_build_url():\n eq_(\"{0}/{1}\".format(client.BASE_URL, \"v1/charges/\"), client.build_url(\"v1/charges/\"))","def get_url(phrase, prefix='all', start=0, max_results=10, sort_by='relevance', sort_order='descending'):\n base_url = 'http://export.arxiv.org/api/query?search_query='\n url = base_url + \\\n prefix+':'+phrase + \\\n '&start='+str(start) + \\\n '&max_results='+str(max_results) + \\\n '&sortBy='+sort_by + \\\n '&sortOrder='+sort_order\n return url","def generate_urls(date: datetime.date) -> List[str]:\n date_string = date.strftime(\"%B-%-d-%Y\").lower()\n url_veggie = (\n f\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\"\n f\"?slug={date_string}-veggie&type[]=page&type[]=topic&type[]=story&\"\n f\"type[]=product&type[]=collection&type[]=event&type[]=menu&\"\n f\"type[]=person&type[]=recipe\"\n )\n url_tday = (\n f\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\"\n f\"?slug={date_string}-thoughtful-t-day&type[]=page&type[]=topic&type[]=story&\"\n f\"type[]=product&type[]=collection&type[]=event&type[]=menu&\"\n f\"type[]=person&type[]=recipe\"\n )\n url = (\n f\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\"\n f\"?slug={date_string}&type[]=page&type[]=topic&type[]=story&\"\n f\"type[]=product&type[]=collection&type[]=event&type[]=menu&\"\n f\"type[]=person&type[]=recipe\"\n )\n return [url_veggie, url_tday, url]","def _route_chunk(data, host_url, annotations='duration', retries=10, extra_params=None):\n\t# offsets are used to make correct indice of the result dataframe\n\tsources, destinations, sources_offset, destinations_offset = data\n\tsources_count = len(sources)\n\tdestinations_count = len(destinations)\n\n\t# OSRM takes all points as one list, and then numbers of sources & dests in it\n\tall_points = sources + destinations\n\tencoded = encode_poly([(p.y, p.x) for p in all_points])\n\n\t# numerate sources & dests. sources come first\n\tsource_numbers = ';'.join(map(str, range(sources_count)))\n\tdestination_numbers = ';'.join(map(str,\n\t\trange(sources_count, sources_count + destinations_count)))\n\n\n\textra_params = extra_params or {}\n\tparams = {\n\t\t'sources': source_numbers,\n\t\t'destinations': destination_numbers,\n\t\t'generate_hints': 'false',\n\t\t'annotations': annotations,\n\t\t**extra_params\n\t}\n\n\tencoded_params = urllib.parse.quote_plus(urllib.parse.urlencode(params))\n\t# if we pass url and params separately to requests.get, it will make a malformed URL\n\tencoded_url = f'{host_url}/table/v1/driving/polyline({encoded})?{encoded_params}'\n\tresp = get_retry(encoded_url, {}, retries)\n\n\tif resp.status_code != 200:\n\t\traise RuntimeError(f'OSRM server responded with {resp.status_code} code. Content: {resp.content}')\n\n\tresp_data = resp.json()\n\tif resp_data.get('code', 'Ok') != 'Ok':\n\t\traise RuntimeError(f'OSRM server responded with error message: {resp_data[\"message\"]}')\n\n\t# if 'duration' is requested, then take resp_data['durations'], or resp_data['distances'] if distances.\n\t# also, 'duration,distance' might be requested, then take both and concatenate results (= join columns)\n\tresults = []\n\t\n\tfor key in annotations.split(','):\n\t\tdf = pd.DataFrame(resp_data[f'{key}s']).reset_index().rename(columns={'index': 'source'}).melt(id_vars='source', var_name='destination', value_name=key)\n\t\tdf[key] = df[key].astype(float)\n\t\tif len(results) > 0:\n\t\t\t# only append the data column\n\t\t\tresults.append(df[[key]])\n\t\telse:\n\t\t\tresults.append(df)\n\n\tresult_df = pd.concat(results, axis=1)\n\n\t# snapping distances\n\tresult_df['source_snap'] = result_df.source.map(pd.DataFrame(resp_data['sources'])['distance'])\n\tresult_df['destination_snap'] = result_df.destination.map(pd.DataFrame(resp_data['destinations'])['distance'])\n\n\t# instead of join/merge lookup\n\tresult_df['geometry'] = result_df['source'].map({i: g for i, g in enumerate(sources)})\n\tresult_df['geometry_dest'] = result_df['destination'].map({i: g for i, g in enumerate(destinations)})\n\n\t# shift back by the given offset\n\tresult_df['destination'] = result_df['destination'].astype(int) + destinations_offset\n\tresult_df['source'] = result_df['source'].astype(int) + sources_offset\n\treturn result_df","def build_api_url(project, method, base_url):\n return API_URL_TEMPLATE.format(\n api_base=base_url, api_version=API_VERSION, project=project, method=method\n )","def _build_url(self, service, resource_type, parameters={}):\n # authenticated dataselect queries have different target URL\n if self.user is not None:\n if service == \"dataselect\" and resource_type == \"query\":\n resource_type = \"queryauth\"\n return build_url(self.base_url, service, self.major_versions[service],\n resource_type, parameters,\n service_mappings=self._service_mappings,\n subpath=self.url_subpath)","def construct_url(self,*path):\n base = self.request.protocol+\"://\"+self.request.host+\"/\"\n return base+\"/\".join(path)","def generate_url(self, campaign_id):\n pass","def home():\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/<start><br/>\"\n f\"/api/v1.0/<start>/<end><br/>\"\n )","def get_proxy_url(self, request, service, url):\n params = None\n logger.debug(\n \"Enter MyUWRestProxyView service: {}, url: {}, GET: {}\".format(\n service, url, request.POST))\n\n if service == \"book\":\n url = \"uw/json_utf8_202007.ubs\"\n url = \"{}?quarter={}&sln1={}&returnlink=t\".format(\n \"uw/json_utf8_202007.ubs\",\n request.POST[\"quarter\"],\n request.POST[\"sln1\"])\n elif service == \"grad\":\n params = self.format_params(request)\n elif service == \"hfs\":\n url = \"myuw/v1/{}\".format(request.POST[\"uwnetid\"])\n elif re.match(r'^iasystem', service):\n if url.endswith('/evaluation'):\n index = url.find('/')\n service = 'iasystem_' + url[:index]\n index += 1\n url = url[index:]\n params = self.format_params(request)\n elif service == \"myplan\":\n url = \"plan/v1/{},{},1,{}\".format(\n request.POST[\"year\"],\n request.POST[\"quarter\"],\n request.POST[\"uwregid\"])\n elif service == \"sws\":\n if \"advisers\" == url:\n url = \"student/v5/person/{}/advisers.json\".format(\n request.POST[\"uwregid\"])\n elif \"degree\" == url:\n url = \"student/v5/person/{}/degree.json?deg_status=all\".format(\n request.POST[\"uwregid\"])\n elif \"notices\" == url:\n url = \"student/v5/notice/{}.json\".format(\n request.POST[\"uwregid\"])\n elif service == \"upass\":\n url = \"upassdataws/api/person/v1/membershipstatus/{}\".format(\n request.POST[\"uwnetid\"])\n elif service == \"uwnetid\":\n if \"password\" == url:\n url = \"nws/v1/uwnetid/{}/password\".format(\n request.POST[\"uwnetid\"])\n elif \"subscription\" == url:\n url = \"nws/v1/uwnetid/{}/subscription/60,64,105\".format(\n request.POST[\"uwnetid\"])\n else:\n service, url, params = super().get_proxy_url(request, service, url)\n\n logger.debug(\n \"Exit MyUWRestProxyView url: {}\".format(url))\n return service, url, params","def _get_url(self, absolute):","def _construct_url(self, endpoint):\n return self.base_url + self.api_path + endpoint.strip('/')","def _urlBuilder(dateString, version, table='events', translation=False):\r\n\r\n if version == 2:\r\n base = \"http://data.gdeltproject.org/gdeltv2/\"\r\n\r\n if version == 1:\r\n base = \"http://data.gdeltproject.org/\"\r\n\r\n if table == \"events\":\r\n if version == 1:\r\n base += 'events/'\r\n if not translation:\r\n caboose = \".export.CSV.zip\"\r\n else:\r\n caboose = \".translation.export.CSV.zip\"\r\n elif table == \"mentions\":\r\n if not translation:\r\n caboose = \".mentions.CSV.zip\"\r\n else:\r\n caboose = \".translation.mentions.CSV.zip\"\r\n elif table == \"gkg\":\r\n if version == 1:\r\n base += 'gkg/'\r\n if isinstance(dateString,str):\r\n comp = _testdate(dateString)\r\n if comp < parse('2013 Apr 1'):\r\n raise Exception('GDELT 1.0 Global Knowledge Graph requires dates greater'\r\n ' than or equal to April 1 2013')\r\n elif isinstance(dateString, list) or isinstance(dateString,\r\n np.ndarray):\r\n if not (np.all(list(\r\n map(\r\n lambda x: x > parse('2013 04 01'), list(\r\n map(\r\n _testdate, dateString)))))):\r\n raise Exception('GDELT 1.0 Global Knowledge Graph requires dates greater'\r\n ' than or equal to April 1 2013')\r\n\r\n\r\n if not translation:\r\n caboose = \".gkg.csv.zip\"\r\n else:\r\n caboose = \".translation.gkg.csv.zip\"\r\n else: # pragma: no cover\r\n raise ValueError('You entered an incorrect GDELT table type.'\r\n ' Choose between \\\"events\\\",\\\"mentions\\\",'\r\n 'and \\\"gkg\\\".')\r\n\r\n\r\n if isinstance(dateString, list) is True or isinstance(dateString,\r\n np.ndarray) is True:\r\n # print(\"This is before any changes {}\".format(dateString))\r\n newdate = []\r\n olddateString = dateString\r\n date=dateString\r\n for l in date:\r\n if len(l) == 4: # pragma: no cover\r\n test = (str(datetime.datetime.strptime(l, '%Y')))\r\n newdate.append(test)\r\n elif len(l) == 6: # pragma: no cover\r\n test = str(datetime.datetime.strptime(l, '%Y%m'))\r\n newdate.append(test)\r\n else:\r\n\r\n test = str(parse(str(l)))\r\n newdate.append(test)\r\n\r\n if version ==1:\r\n if table != 'gkg':\r\n # print(base)\r\n base\r\n # print(\"After {}\".format(base))\r\n\r\n if not (np.all(list(\r\n map(\r\n lambda x: x > parse('2013 04 01'), list(\r\n map(\r\n _testdate, dateString)))))): # pragma: no cover\r\n\r\n return (list(\r\n map(lambda x: base + x + \".zip\" if _testdate(\r\n x).date() < parse(\r\n '2013 04 01').date() else base + x + caboose,\r\n dateString)))\r\n\r\n else:\r\n\r\n return list(map(lambda x: base + x + caboose, olddateString))\r\n\r\n elif isinstance(dateString, str) is True or len(dateString) == 1:\r\n\r\n if version == 1:\r\n if table=='events':\r\n if len(dateString) == 4:\r\n comp = datetime.datetime.strptime(dateString,'%Y')\r\n elif len(dateString) == 6:\r\n comp = datetime.datetime.strptime(dateString, '%Y%m')\r\n else:\r\n comp = parse(dateString)\r\n if comp < parse('2013 Apr 01'):\r\n caboose = \".zip\"\r\n elif table == 'events':\r\n caboose = \".export.CSV.zip\"\r\n\r\n if isinstance(dateString, list) is True or isinstance(\r\n dateString, np.ndarray) is True: # pragma: no cover\r\n dateString = dateString[0]\r\n if parse(dateString[0]) < parse('2013 Apr 01'):\r\n caboose = \".zip\"\r\n\r\n return base + dateString + caboose","def home():\n return (\n f\"Available Routes:<br/>\"\n f\"/api/v1.0/precipitation<br/>\"\n f\"/api/v1.0/stations<br/>\"\n f\"/api/v1.0/tobs<br/>\"\n f\"/api/v1.0/start_date(yyyy-mm-dd)<br/>\"\n f\"/api/v1.0/start_date(yyyy-mm-dd)/end_date(yyyy-mm-dd)<br/>\")","def apiurl (self):\n return Links.createAPIURL (\n '/boards.json'\n )","def create_url(model, trips_year):\n return model.create_url(trips_year)","def build_url(self, dict_args_in_out=None):\n if dict_args_in_out is None:\n dict_args_in_out = {}\n\n url = dict_args_in_out.pop('base_url', None) or ''\n url += '/%s' % self.collection_key\n\n # do we have a specific entity?\n entity_id = dict_args_in_out.pop('%s_id' % self.key, None)\n if entity_id is not None:\n url += '/%s' % entity_id\n\n return url","def barbican_url(self):","def __build_url(path, api_site_parameter, **params):\n \n query = [\"%s=%s\" % (key, params[key]) for key in params if (params[key] or key == 'pagesize') ]\n query_string = \"&\".join(query)\n url = \"%s/%s/%s?\" % (__api_endpoint, __api_version, path)\n url += query_string\n return url","def build_details_url(self, params={}):\n\n if 'url' in params:\n url = params['url']\n url += '?page=' + str(int(params['page'])) + '&sort=' + str(params['sort'])\n return url"],"string":"[\n \"def create_url(_origin_details, travel_start_date, travel_start_time, destination_list):\\n prefix = 'https://timetable.search.ch/api/route.json?one_to_many=1'\\n\\n origin_body = f'&from={_origin_details}&date={travel_start_date}&time={travel_start_time}'\\n\\n # Build iteratively with necessary syntax between destinations\\n destination_body = ''\\n for i, dest in enumerate(destination_list):\\n destination_body = f'{destination_body}&to[{i}]={dest}'\\n\\n return f'{prefix}{origin_body}{destination_body}'\",\n \"def build_url(ori_lon, ori_lat, des_lon, des_lat, year, month, day, hour, minute, args={}):\\n options = dict()\\n with open(option_file, 'r', newline='') as file:\\n # Read the options file\\n for line in file:\\n if line[0] == '#': # if the first character of a line is '#' skip it\\n continue\\n splited_line = line.rstrip().split(':')\\n if len(splited_line) < 2: # if it is a line with no ':'\\n continue\\n options[splited_line[0]] = splited_line[1]\\n base_URL = 'localhost:' + port + '/otp/routers/default/plan'\\n fromPlace = ori_lon + ',' + ori_lat\\n toPlace = des_lon + ',' + des_lat\\n date = year + '/' + month + '/' + day\\n time = hour + ':' + minute + ':00'\\n\\n url = 'http://' + base_URL + '?fromPlace=' + fromPlace + '&toPlace=' + toPlace + '&date=' + date + '&time=' + time\\n for option_name in options.keys():\\n option = options[option_name]\\n url += '&' + option_name + '=' + option\\n if not 'mode' in url:\\n url += '&mode=TRANSIT,WALK'\\n for key in args.keys():\\n url+= '&' + key + '=' + args[key]\\n\\n return url\",\n \"def urlGenerator(self):\\n \\n # VERMONT #\\n baseurl = 'https://www.vermontjudiciary.org'\\n path = '/opinions-decisions'\\n # from date\\n param1 = 'facet_from_date=01/01'\\n # to date\\n param2 = 'facet_to_date=01/01/'\\n # division\\n param3 = 'f%5B0%5D=court_division_opinions_library%3A'\\n # search by text\\n param4 = 'search_api_fulltext='\\n # page\\n param5 = 'page='\\n # generate list of URL\\n listURL = []\\n \\n # list of divisions\\n vt_court_division = {\\\"civil\\\": \\\"1\\\", \\\"supreme court\\\": \\\"7\\\", \\\"environmental\\\": \\\"3\\\", \\\"family\\\": \\\"4\\\", \\\"criminal\\\": \\\"2\\\"}\\n # inputs\\n from_year = 2000\\n to_year = 2017\\n endPages = 75 #0-74\\n startPages = 0\\n # make change to pull data from different division by changing division name below to any of the division in vt_court_vivision dict\\n division = vt_court_division[\\\"environmental\\\"]\\n # url generating\\n for i in range(startPages, endPages):\\n build_url = baseurl + path + '?' + param1 + str(from_year) + \\\"&\\\" + param2 + str(to_year) + \\\"&\\\" + param3 + division + param4 + \\\"&\\\" + param5 + str(i) + \\\"\\\"\\n # append url to listUrl\\n listURL.append(build_url)\\n i += 1\\n \\n # return full list of URLs\\n return listURL\",\n \"def gen_url(self):\\n self.url = \\\"https://www.cubedb.net/?rank=3&title={}&time={}&scramble=\\\".format(self.name_of_solve, self.time_solve)\\n for move in self.scramble.split():\\n if \\\"\\\\'\\\" in move:\\n move.replace(\\\"\\\\'\\\", \\\"-\\\")\\n self.url += \\\"{}_\\\".format(move)\\n self.url += \\\"&alg=\\\"\\n count = 0\\n for move in self.solve_stats:\\n if self.comms_unparsed_bool:\\n if self.comms_unparsed_bool:\\n if move[\\\"comment\\\"] != \\\"\\\":\\n if \\\"mistake\\\" in move[\\\"comment\\\"]:\\n move[\\\"comment\\\"] = \\\"{}%0A//{}\\\".format(move[\\\"comment\\\"].split(\\\"mistake\\\")[0],\\n \\\"mistake from here\\\")\\n if \\\"#\\\" in move[\\\"comment\\\"]:\\n piece = move[\\\"comment\\\"].split(\\\"#\\\")[0]\\n move[\\\"comment\\\"] = move[\\\"comment\\\"].split(\\\"#\\\")[1]\\n if self.url.rfind(\\\"%0A\\\") != -1:\\n alg = self.url[self.url.rfind(\\\"%0A\\\") + 3:]\\n self.url = self.url[:self.url.rfind(\\\"%0A\\\") + 3] + \\\"%0A//{}%0A\\\".format(piece) + alg\\n else:\\n alg = self.url[self.url.rfind(\\\"=\\\") + 1:]\\n self.url = self.url[:self.url.rfind(\\\"=\\\") + 1] + \\\"%0A//{}%0A\\\".format(piece) + alg\\n self.url += self.comms_unparsed[count]\\n count += 1\\n self.url += \\\"// {} %0A\\\".format(move[\\\"comment\\\"])\\n\\n\\n else:\\n if \\\"move\\\" in move:\\n if move[\\\"move\\\"] != \\\"\\\":\\n if \\\"\\\\'\\\" in move[\\\"move\\\"]:\\n move[\\\"move\\\"].replace(\\\"\\\\'\\\", \\\"-\\\")\\n self.url += \\\"{}_\\\".format(move[\\\"move\\\"])\\n if move[\\\"comment\\\"] != \\\"\\\":\\n if \\\"mistake\\\" in move[\\\"comment\\\"]:\\n move[\\\"comment\\\"] = \\\"{}%0A//{}\\\".format(move[\\\"comment\\\"].split(\\\"mistake\\\")[0], \\\"mistake from here\\\")\\n if \\\"#\\\" in move[\\\"comment\\\"]:\\n piece = move[\\\"comment\\\"].split(\\\"#\\\")[0]\\n move[\\\"comment\\\"] = move[\\\"comment\\\"].split(\\\"#\\\")[1]\\n if self.url.rfind(\\\"%0A\\\") != -1:\\n alg = self.url[self.url.rfind(\\\"%0A\\\") + 3:]\\n self.url = self.url[:self.url.rfind(\\\"%0A\\\") + 3] + \\\"//{}%0A\\\".format(piece) + alg\\n else:\\n alg = self.url[self.url.rfind(\\\"=\\\") + 1:]\\n self.url = self.url[:self.url.rfind(\\\"=\\\") + 1] + \\\"//{}%0A\\\".format(piece) + alg\\n\\n self.url += \\\"// {} %0A\\\".format(move[\\\"comment\\\"])\\n else:\\n self.url += \\\"// {} %0A\\\".format(move[\\\"comment\\\"])\",\n \"def getURLs():\",\n \"def _make_url(self):\\n ...\",\n \"def build_url(vehicle, coordinates, format=\\\"json\\\", geometryformat=\\\"isoz\\\"):\\n load = vehicle.load if vehicle.load > -1.0 else 0\\n params = {\\n \\\"format\\\": format,\\n \\\"height\\\": vehicle.height,\\n \\\"length\\\": vehicle.length,\\n \\\"stops\\\": coordinates,\\n \\\"load\\\": load,\\n \\\"geometryformat\\\": geometryformat,\\n \\\"lang\\\": \\\"nb-no\\\",\\n }\\n\\n return '?'.join([ROUTE_URL_BASE, urlencode(params)])\",\n \"def generate_url(self):\\n if self.has_marker:\\n marker_param = f'mlat={self.mlat}&mlng={self.mlng}&'\\n else:\\n marker_param = ''\\n if self.start:\\n start_param = 'start=true&'\\n else:\\n start_param = ''\\n url = f'{MapController.MAP_URL}?{start_param}clat={self.clat}&clng={self.clng}&{marker_param}zoom={self.zoom}'\\n return url\",\n \"def make_url(site,node,instrument,method,stream,API_USERNAME,API_TOKEN):\\n\\n SENSOR_BASE_URL = 'https://ooinet.oceanobservatories.org/api/m2m/12576/sensor/inv/'\\n VOCAB_BASE_URL = 'https://ooinet.oceanobservatories.org/api/m2m/12586/vocab/inv'\\n meta_request_url ='/'.join((VOCAB_BASE_URL,site,node,instrument)) # Python wizard best\\n data_request_url ='/'.join((SENSOR_BASE_URL,site,node,instrument,method,stream))\\n\\n # Retrieve vocabulary information for a given instrument\\n r = requests.get(meta_request_url, auth=(API_USERNAME, API_TOKEN))\\n meta_data = r.json()\\n\\n return (data_request_url,meta_data)\",\n \"def routes():\\n import urllib.request, urllib.parse, urllib.error\\n output = []\\n for rule in app.url_map.iter_rules():\\n options = {}\\n for arg in rule.arguments:\\n options[arg] = \\\"[{0}]\\\".format(arg)\\n methods = ','.join(rule.methods)\\n url = url_for(rule.endpoint, **options)\\n line = urllib.parse.unquote(\\\"{:50s} {:20s} {}\\\".format(rule.endpoint, methods, url))\\n output.append(line)\\n for line in sorted(output):\\n print (line)\",\n \"def drivingdistance(origin, destination, APIkey):\\n\\n lat1, lon1 = origin\\n lat2, lon2 = destination\\n\\n gm_url = ('https://maps.googleapis.com/maps/api/directions/xml?' +\\n 'origin='+str(lat1) + ',' + str(lon1) +\\n '&destination=' + str(lat2) + ','+str(lon2) +\\n '&key='+APIkey)\\n\\n return gm_url\",\n \"def _create_api_ulr_list(self) -> List[str]:\\n api = Setup.openweather_api\\n now = int(time.time())\\n urls_list = []\\n\\n for lat, lon in self.locations:\\n urls_list.append(\\n f\\\"https://api.openweathermap.org/data/2.5/onecall?\\\"\\n f\\\"lat={lat}&lon={lon}&exclude=hourly,minutely,\\\"\\n f\\\"alerts&units=metric&appid={api}\\\"\\n )\\n\\n for days in range(1, 6):\\n date_time = now - 86400 * days\\n urls_list.append(\\n f\\\"http://api.openweathermap.org/data/2.5/onecall/\\\"\\n f\\\"timemachine?lat={lat}&lon={lon}&dt={date_time}\\\"\\n f\\\"&units=metric&appid={api}\\\"\\n )\\n\\n return urls_list\",\n \"def uri(self):\\n if not self.parallel:\\n if len(self.WMO) <= 5: # todo: This max WMO number should be parameterized somewhere else\\n # Retrieve all WMOs in a single request\\n return [self.get_url()]\\n else:\\n # Retrieve one WMO by URL sequentially (same behaviour as localftp and argovis)\\n urls = []\\n for wmo in self.WMO:\\n urls.append(\\n Fetch_wmo(\\n WMO=wmo, CYC=self.CYC, ds=self.dataset_id, parallel=False\\n ).get_url()\\n )\\n return urls\\n else:\\n self.Chunker = Chunker(\\n {\\\"wmo\\\": self.WMO}, chunks=self.chunks, chunksize=self.chunks_maxsize\\n )\\n wmo_grps = self.Chunker.fit_transform()\\n # self.chunks = C.chunks\\n urls = []\\n for wmos in wmo_grps:\\n urls.append(\\n Fetch_wmo(\\n WMO=wmos, CYC=self.CYC, ds=self.dataset_id, parallel=False\\n ).get_url()\\n )\\n return urls\",\n \"def test_url_construction(self):\\n\\n a = api.InvenTreeAPI(\\\"http://localhost:1234\\\", connect=False)\\n\\n tests = {\\n 'part': 'http://localhost:1234/api/part/',\\n '/part': 'http://localhost:1234/api/part/',\\n '/part/': 'http://localhost:1234/api/part/',\\n 'order/so/shipment': 'http://localhost:1234/api/order/so/shipment/',\\n }\\n\\n for endpoint, url in tests.items():\\n self.assertEqual(a.constructApiUrl(endpoint), url)\",\n \"def __get_urls(self):\\n self.__valid_servers = {\\n \\\"qa\\\": {\\n \\\"server_url\\\": \\\"https://qa.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://qa.api.deepaffex.ai:9080\\\"\\n },\\n \\\"dev\\\": {\\n \\\"server_url\\\": \\\"https://dev.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://dev.api.deepaffex.ai:9080\\\"\\n },\\n \\\"demo\\\": {\\n \\\"server_url\\\": \\\"https://demo.api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://demo.api.deepaffex.ai:9080\\\"\\n },\\n \\\"prod\\\": {\\n \\\"server_url\\\": \\\"https://api.deepaffex.ai:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://api.deepaffex.ai:9080\\\"\\n },\\n \\\"prod-cn\\\": {\\n \\\"server_url\\\": \\\"https://api.deepaffex.cn:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://api.deepaffex.cn:9080\\\"\\n },\\n \\\"demo-cn\\\": {\\n \\\"server_url\\\": \\\"https://demo.api.deepaffex.cn:9443\\\",\\n \\\"websocket_url\\\": \\\"wss://demo.api.deepaffex.cn:9080\\\"\\n }\\n }\\n try:\\n self.server_url = self.__valid_servers[self.server][\\\"server_url\\\"]\\n self.websocket_url = self.__valid_servers[self.server][\\\"websocket_url\\\"]\\n except KeyError:\\n raise KeyError(\\\"Invalid server ID given\\\")\",\n \"def get_url(self, source):\\n if source == 'nomads':\\n if self.model == 'rap':\\n base = 'https://nomads.ncep.noaa.gov/pub/data/nccf/com/rap/prod/'\\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\\n else:\\n base = 'https://nomads.ncep.noaa.gov/pub/data/nccf/com/hrrr/prod/'\\n if self.model == 'hrrr':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\\\"\\n elif self.model == 'hrrrak':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\\\"\\n elif source == 'aws':\\n if self.model == 'rap':\\n base = 'https://noaa-rap-pds.s3.amazonaws.com/'\\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\\n else:\\n base = 'https://noaa-hrrr-bdp-pds.s3.amazonaws.com/'\\n if self.model == 'hrrr':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\\\"\\n elif self.model == 'hrrrak':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\\\"\\n elif source == 'google':\\n if self.model == 'rap':\\n base = 'https://storage.googleapis.com/rapid-refresh/'\\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\\n else:\\n base = 'https://storage.googleapis.com/high-resolution-rapid-refresh/'\\n if self.model == 'hrrr':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\\\"\\n elif self.model == 'hrrrak':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\\\"\\n elif source == 'azure':\\n if self.model == 'rap':\\n base = 'https://noaarap.blob.core.windows.net/rap'\\n path = f'rap.{self.date:%Y%m%d}/rap.t{self.date:%H}z.awip32f{self.fxx:02d}.grib2'\\n else:\\n base = 'https://noaahrrr.blob.core.windows.net/hrrr/'\\n if self.model == 'hrrr':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/conus/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\\\"\\n elif self.model == 'hrrrak':\\n path = f\\\"hrrr.{self.date:%Y%m%d}/alaska/hrrr.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.ak.grib2\\\"\\n elif source.startswith('pando'):\\n if source[-1] == '2':\\n gateway = 2\\n else:\\n gateway = 1\\n if self.model == 'rap':\\n return None # No RAP data on Pando\\n else:\\n base = f'https://pando-rgw0{gateway}.chpc.utah.edu/'\\n path = f\\\"{self.model}/{self.field}/{self.date:%Y%m%d}/{self.model}.t{self.date:%H}z.wrf{self.field}f{self.fxx:02d}.grib2\\\"\\n \\n return base+path\",\n \"def calc_url(self):\\n place = self._get_first_place()[0]\\n path = \\\"\\\"\\n # First see if we are in or near Sweden or Denmark\\n # Change country to upper case\\n location = get_main_location(self.database, place)\\n country = location.get(PlaceType.COUNTRY, '').upper().strip()\\n country_given = (country in MAP_NAMES_SWEDEN or \\\\\\n country in MAP_NAMES_DENMARK) and (country != \\\"\\\")\\n # if no country given, check if we might be in the vicinity defined by\\n # 54 33' 0\\\" < lat < 66 9' 0\\\", 54.55 and 69.05\\n # 8 3' 0\\\" < long < 24 9' 0\\\", 8.05 and 24.15 \\n latitude, longitude = self._lat_lon(place)\\n if latitude is None or longitude is None:\\n coord_ok = False\\n else:\\n latitude = float(latitude) \\n longitude = float(longitude)\\n # Check if coordinates are inside Sweden and Denmark\\n if (54.55 < latitude < 69.05) and (8.05 < longitude < 24.15):\\n coord_ok = True\\n else:\\n msg2 = _(\\\"Latitude not within '54.55' to '69.05'\\\\n\\\") + \\\\\\n _(\\\"Longitude not within '8.05' to '24.15'\\\")\\n WarningDialog(_(\\\"Eniro map not available\\\"), msg2 )\\n return\\n\\n if coord_ok:\\n place_title = _build_title(self.database, place)\\n place_city = _build_city(self.database, place)\\n x_coord, y_coord = self._lat_lon(place, format=\\\"RT90\\\")\\n # Set zoom level to 5 if Sweden/Denmark, others 3\\n zoom = 5\\n if not country_given:\\n zoom = 3\\n path = \\\"http://www.eniro.se/partner.fcgi?pis=1&x=%s&y=%s\\\" \\\\\\n \\\"&zoom_level=%i&map_size=0&title=%s&city=%s&partner=gramps\\\"\\n # Note x and y are swapped!\\n path = path % (y_coord , x_coord, zoom, place_title, place_city)\\n self.url = path.replace(\\\" \\\",\\\"%20\\\")\\n return\\n\\n place_area = _build_area(self.database, place)\\n if country_given and place_area:\\n if country in MAP_NAMES_SWEDEN:\\n path = \\\"http://kartor.eniro.se/query?&what=map_adr&mop=aq\\\" \\\\\\n \\\"&geo_area=%s&partner=gramps\\\"\\n path = path % (place_area)\\n self.url = path.replace(\\\" \\\",\\\"%20\\\")\\n return\\n else:\\n WarningDialog(_(\\\"Eniro map not available\\\"), \\\\\\n _(\\\"Coordinates needed in Denmark\\\") )\\n self.url = \\\"\\\"\\n return\\n\\n WarningDialog(_(\\\"Eniro map not available\\\"), \\n _(\\\"Latitude and longitude,\\\\n\\\" \\\\\\n \\\"or street and city needed\\\") )\\n return\",\n \"def getDataUrls(self):\\n sub1 = self.id[0:3]\\n sub2 = self.id[3:6]\\n sub3 = self.id[6:9]\\n self.xml = \\\"%s/static/model/%s/%s/%s/%s.xml\\\" % (serverString, sub1, sub2, sub3, self.id)\\n self.image = \\\"%s/static/image/%s/%s/%s/%s_lrg.png\\\" % (serverString, sub1, sub2, sub3, self.id)\\n self.thumb = \\\"%s/static/thumb/%s/%s/%s/%s.png\\\" % (serverString, sub1, sub2, sub3, self.id)\",\n \"def build_urls(self, listings_per_page=20, pages_per_location=15):\\r\\n url_list = []\\r\\n for i in range(pages_per_location):\\r\\n offset = listings_per_page * i\\r\\n url_pagination = self.link + f'&items_offset={offset}'\\r\\n url_list.append(url_pagination)\\r\\n self.url_list = url_list\",\n \"def build_url(self):\\n return self.data_url.format(latitude=self.latitude, longitude=self.longitude)\",\n \"def _generate_urls(base_url, mbid):\\n for level in LEVELS:\\n yield base_url + mbid + level\",\n \"def url_shortner(self):\",\n \"def create_web_output_paths() -> None:\\n create_path_and_index(\\\"\\\")\\n create_path_and_index(\\\"photos/\\\")\\n create_path_and_index(\\\"video/\\\")\\n create_path_and_index(\\\"references/\\\")\\n create_path_and_index(\\\"names/\\\")\\n create_path_and_index(\\\"art/\\\")\\n create_path_and_index(\\\"morphology/\\\")\\n create_path_and_index(\\\"maps/\\\")\\n create_path_and_index(\\\"images/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/css/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/flags/\\\")\\n create_path_and_index(\\\"images/flag-icon-css/flags/4x3/\\\")\\n create_path_and_index(\\\"locations/\\\")\\n create_path_and_index(\\\"locations/keys/\\\")\\n create_path_and_index(\\\"js/\\\")\\n create_path_and_index(\\\"sizes/\\\")\\n create_path_and_index(\\\"handedness/\\\")\",\n \"def _url_builder(url_root,api_key,path,params):\\n params['api_key'] = api_key\\n url_end = urlencode(params)\\n url = \\\"%s%s%s\\\" % (url_root,path,url_end)\\n return url\",\n \"def Url(self) -> str:\",\n \"def test_urls(self):\\n self.base_check_request(\\\"get\\\", \\\"/\\\")\\n self.base_check_request(\\\"get\\\", \\\"apartments/\\\")\\n self.base_check_request(\\\"get\\\", \\\"complexes/\\\")\\n self.base_check_request(\\\"get\\\", \\\"locations/\\\")\\n self.base_check_request(\\\"get\\\", \\\"companies/\\\")\\n self.base_check_request(\\\"get\\\", \\\"companies-types/\\\")\\n\\n self.base_check_request(\\\"get\\\", \\\"count/apartments/\\\")\\n self.base_check_request(\\\"get\\\", \\\"count/complexes/\\\")\\n\\n self.base_check_request(\\\"get\\\", \\\"search-forms/apartments/\\\")\\n self.base_check_request(\\\"get\\\", \\\"search-forms/complexes/\\\")\\n self.base_check_request(\\\"get\\\", \\\"search-forms/main/\\\")\\n\\n self.base_check_request(\\\"get\\\", \\\"autocomplete/companies/\\\")\\n self.base_check_request(\\\"get\\\", \\\"autocomplete/complexes/\\\")\\n self.base_check_request(\\\"get\\\", \\\"autocomplete/locations/\\\")\\n\\n self.base_check_request(\\\"get\\\", \\\"apartments_for_maps/?count=1&fields=lat,lon\\\")\\n # self.base_check_request(\\\"get\\\", \\\"reserve/\\\")\\n # self.base_check_request(\\\"get\\\", \\\"complain/\\\")\\n # self.base_check_request(\\\"post\\\", \\\"apartment-complain/\\\")\\n # self.base_check_request(\\\"post\\\", \\\"order-apartment/\\\")\",\n \"def getSDDCT0routes(proxy_url, session_token):\\n t0_routes_json = get_sddc_t0_routes_json(proxy_url, session_token)\\n t0_routes = {}\\n if 'results' in t0_routes_json:\\n pass\\n else:\\n print(\\\"No results. Something went wrong - please check your syntax and try again.\\\")\\n sys.exit(1)\\n\\n if t0_routes_json == None:\\n print(\\\"API Error\\\")\\n sys.exit(1)\\n elif len(t0_routes_json['results']) == 1:\\n t0_routes = t0_routes_json['results'][0]['route_entries']\\n elif len(t0_routes_json['results']) >1:\\n t0_routes0 = t0_routes_json['results'][0]['route_entries']\\n t0_routes1 = t0_routes_json['results'][1]['route_entries']\\n t0_routes = t0_routes0 + t0_routes1\\n\\n df = pd.DataFrame(t0_routes)\\n df.drop(['lr_component_id', 'lr_component_type'], axis=1, inplace=True)\\n df.drop_duplicates(inplace = True)\\n print('T0 Routes')\\n print('Route Type Legend:')\\n print('t0c - Tier-0 Connected\\\\nt0s - Tier-0 Static\\\\nb - BGP\\\\nt0n - Tier-0 NAT\\\\nt1s - Tier-1 Static\\\\nt1c - Tier-1 Connected\\\\nisr: Inter-SR')\\n print()\\n print(df.sort_values(by=[ 'route_type', 'network'], ascending=True).to_string())\\n # route_table = PrettyTable(['Route Type', 'Network', 'Admin Distance', 'Next Hop'])\\n # for routes in t0_routes:\\n # route_table.add_row([routes['route_type'],routes['network'],routes['admin_distance'],routes['next_hop']])\\n # print (route_table.get_string(sort_key = operator.itemgetter(1,0), sortby = \\\"Network\\\", reversesort=True))\",\n \"def ajax_solve():\\n\\n # The possible errors and their human-readable messages\\n ERRORS = {\\n 403: \\\"Google Directions could not find a path\\\",\\n 404: \\\"Google Directions did not send response\\\",\\n 405: \\\"You did not specify a start\\\",\\n 406: \\\"You need to specify at least two waypoints\\\",\\n 407: \\\"You did not specify a valid algorithm\\\",\\n 408: \\\"Internal Algorithm Error\\\",\\n\\n }\\n\\n\\n def to_tuple(waypoint):\\n \\\"\\\"\\\"\\n Converts LatLng dicts to tuples.\\n\\n :param waypoint: A waypoint as string, tuple or LatLng dict\\n :return: waypoint, if waypoint is string or tuple,\\n a tuple of the lat and lng values, if dict\\n\\n \\\"\\\"\\\"\\n if isinstance(waypoint, dict):\\n return (waypoint[\\\"lat\\\"], waypoint[\\\"lng\\\"])\\n else:\\n return waypoint\\n\\n def to_dict(waypoint):\\n \\\"\\\"\\\"\\n Converts to tuples to LatLng dicts.\\n\\n :param waypoint: A waypoint as string or tuple\\n :return: waypoint, if waypoint is string or tuple,\\n a LatNg dict, if tuple\\n \\\"\\\"\\\"\\n if isinstance(waypoint, tuple):\\n return {\\\"lat\\\": waypoint[0], \\\"lng\\\": waypoint[1]}\\n else:\\n return waypoint\\n\\n\\n\\n # Get the arguments\\n json = request.args\\n\\n # Check that a start point is supplied\\n start = json.get(\\\"origin\\\")\\n if not start:\\n return jsonify(status=406, msg=ERRORS[405])\\n\\n # Convert to tuple if necessary\\n # This is needed to store waypoints as keys in a dict\\n start = to_tuple(start)\\n\\n\\n\\n waypoints = json.getlist(\\\"waypoints[]\\\")\\n if not waypoints:\\n return jsonify(status=406, msg=ERRORS[406])\\n\\n # We need to have at least two points for a path\\n if len(waypoints) < 2:\\n return jsonify(status=406, msg=ERRORS[406])\\n\\n # Convert to tuple if necessary\\n # This is needed to store waypoints as keys in a dict\\n waypoints = map(to_tuple, waypoints)\\n\\n # Get the algorithm\\n algorithm = algorithms[json[\\\"algo\\\"]]\\n if not algorithm:\\n return jsonify(status=407, msg=ERRORS[407])\\n\\n # Get the options\\n options = {}\\n for option in algorithm.options():\\n options[option] = float(json.get(\\\"options[%s]\\\" % option))\\n\\n try:\\n distances = matrix.create(waypoints)\\n except BaseException as e:\\n logging.warning(\\\"Exception %s while creating matrix for %s\\\" % (e, waypoints))\\n return jsonify(status=404, msg=ERRORS[404])\\n else:\\n if distances:\\n\\n try:\\n # Call the algorithm\\n l, path = algorithm.solve(start, distances, **options)\\n except BaseException as e:\\n logging.warning(\\\"Exception %s while executing %s with %s\\\" % (e, algorithm.name, options))\\n return jsonify(status=408, msg=ERRORS[408])\\n else:\\n # Pack result\\n result = {\\n \\\"status\\\": 200,\\n \\\"length\\\": l,\\n \\\"start\\\": start,\\n \\\"algo\\\": json[\\\"algo\\\"],\\n \\\"path\\\": map(to_dict, path),\\n \\\"msg\\\": \\\"SUCCESS\\\"\\n }\\n\\n # Return the result\\n return jsonify(result)\\n else:\\n return jsonify(status=403, msg=ERRORS[403])\",\n \"def get_urls(self):\\n \\n url_strings = dict()\\n \\n \\n for platform in constants.PLATFORMS:\\n download_path = reverse('download-installer', kwargs={\\n 'build_id': self.build_id,\\n 'platform': platform,\\n })\\n \\n url_strings[platform] = settings.BASE_URL.rstrip('/') + download_path\\n \\n \\n return url_strings\",\n \"def get_urls(self, **kwargs):\\n pass # pragma: no cover\",\n \"def url(self):\\n ...\",\n \"async def api():\\n return {\\n \\\"links\\\": {\\n \\\"datasets\\\": \\\"/datasets\\\",\\n \\\"natural_earth_feature\\\": \\\"/natural_earth_feature\\\",\\n \\\"viewport\\\": \\\"/viewport\\\"\\n }\\n }\",\n \"def roadSegments(locations, API_key=\\\"Avah46_M-gfFeQ3P1w09Qq1ElAV9ZEHFDm9b8JRCRa8qPP5uVn21hDqAPVJgV4i_\\\"): \\n \\n # Base URL\\n uri = 'http://dev.virtualearth.net/' # Resource URL \\n path = 'REST/v1/Routes?'\\n \\n \\n # URL Parameters\\n params = { 'wayPoint.0' : locations[0]+',Singapore',\\n 'wayPoint.1' : locations[1]+',Singapore',\\n 'routeAttributes':'routePath',\\n 'key' : API_Key} # by default 'optimize' : 'time'} # this is by default\\n \\n url = uri+path\\n\\n results = requests.get(\\n url,\\n params = params\\n ).json()# ['resourceSets']\\n\\n # Retrieving values\\n statusCode = results['statusCode']\\n if statusCode == 200:\\n # print(statusCode)\\n\\n # TODO review the exceptions and modify these basic exception handlings\\n try:\\n travelDistance = results['resourceSets'][0]['resources'][0]['travelDistance']\\n except:\\n travelDistance = 0\\n try:\\n travelDuration = results['resourceSets'][0]['resources'][0]['travelDuration']\\n except:\\n travelDuration = 0\\n try:\\n travelDurationTraffic = results['resourceSets'][0]['resources'][0]['travelDurationTraffic']\\n except:\\n travelDurationTraffic = 0\\n\\n try:\\n numberSegments = len(results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\\\\n ['itineraryItems'])\\n except:\\n numberSegments = 0\\n try:\\n itineraryItems = results['resourceSets'][0]['resources'][0]['routeLegs'][0] \\\\\\n ['itineraryItems']\\n except:\\n itineraryItems = 'No items'\\n\\n pathCoord = results['resourceSets'][0]['resources'][0]['routePath']['line']['coordinates']\\n\\n roadName = []\\n travelDistances = []\\n travelDurations = []\\n maneuverType = []\\n\\n for seg in itineraryItems:\\n for i in range(len(seg['details'])):\\n # print(i)\\n try:\\n roadName.append(seg['details'][i]['names'])\\n except:\\n roadName.append(0)\\n try:\\n travelDistances.append(seg['travelDistance'])\\n except:\\n travelDistances.append(0)\\n\\n try:\\n travelDurations.append(seg['travelDuration'])\\n except:\\n travelDurations.append(0)\\n try:\\n maneuverType.append(seg['details'][i]['maneuverType'])\\n except:\\n maneuverType.append(0)\\n\\n\\n return statusCode,travelDistance,travelDuration,travelDurationTraffic,numberSegments,roadName, \\\\\\n travelDistances, travelDurations, maneuverType, pathCoord\\n\\n else:\\n print(\\\"Unsuccessful route calculation.\\\")\",\n \"def getSDDCT0staticroutes(proxy_url,session_token):\\n t0_static_routes_json = get_sddc_t0_static_routes_json(proxy_url, session_token)\\n if t0_static_routes_json == None:\\n print(\\\"API Error\\\")\\n sys.exit(1)\\n if 'results' in t0_static_routes_json:\\n t0_static_routes = t0_static_routes_json['results']\\n else:\\n print(\\\"No results. Something went wrong - please check your syntax and try again.\\\")\\n sys.exit(1)\\n route_table = PrettyTable(['Display Name', 'Network', 'Admin Distance', 'Next Hop'])\\n for routes in t0_static_routes:\\n route_table.add_row([routes['display_name'],routes['network'],routes['next_hops'][0]['admin_distance'],routes['next_hops'][0]['ip_address']])\\n print (route_table.get_string(sort_key = operator.itemgetter(1,0), sortby = \\\"Network\\\", reversesort=True))\",\n \"def home():\\n return(\\n f\\\"Available Routes: <br/>\\\"\\n\\n f\\\"For Precipitation: /api/v1.0/precipitation<br/>\\\"\\n f\\\"Returns Jsonify dictionary of dates and Precepitation<br/><br/>\\\"\\n\\n f\\\"For list of Stations: /api/v1.0/stations<br/>\\\"\\n f\\\"Returns Jasonify list of stations <br/><br/>\\\"\\n\\n f\\\"For last year temperatures: /api/v1.0/tobs<br/>\\\"\\n f\\\"Returns Jsonify dictionary of Temperature Observations for last year<br/><br/>\\\"\\n\\n f\\\"Temperature result from the date in format (yyyy-mm-dd): /api/v1.0/yyyy-mm-dd<br/>\\\"\\n f\\\"Returns an Average, Max, and Min temperatures from given start date of dataset<br/><br/>\\\"\\n\\n f\\\"Temperature result from start date to end date in format (yyyy-mm-dd): /api/v1.0/yyyy-mm-dd/yyyy-mm-dd<br/>\\\"\\n f\\\"Returns an Average, Max, and Min temperatures for a given date range\\\"\\n\\n )\",\n \"def _build_directions(self):\\n d = {'start': self.get_start(), 'end': self.get_end(), 'duration': self.get_duration(),\\n 'mode': self.get_primary_mode(), 'price_range': self.get_price_range(), 'legs': self.get_legs(),\\n 'start_location': self.get_start_location(), 'end_location': self.get_end_location()}\\n self.set_directions(d)\",\n \"def build_url(main_url, url_params):\\n return main_url + \\\"/\\\" + \\\"/\\\".join(url_params)\",\n \"def visualize(g):\\n url = \\\"http://www.gcmap.com/mapui?P=\\\"\\n routes = []\\n \\n for key in g.city_dict:\\n for flight in g.city_dict[key].get_flights_out():\\n route = (g.city_dict[key].get_code(), flight[0])\\n if(route not in routes):\\n routes.append(route)\\n \\n for flight in routes:\\n url = url + flight[0] + \\\"-\\\" + flight[1]\\n url = url + \\\",+\\\"\\n \\n url = url[:-2]\\n return url\",\n \"def _generate_url(action, query_params=None):\\r\\n if query_params:\\r\\n query_params = urllib.parse.urlencode(query_params)\\r\\n action = f\\\"{action}?{query_params}\\\"\\r\\n \\r\\n\\r\\n url = urllib.parse.urljoin(api_url, action)\\r\\n\\r\\n return url\",\n \"def next_xml_url(query_url, query_points, routers):\\n index = 4\\n last_query_point = \\\"\\\"\\n query = str(query_points[0])\\n if query == \\\"stats\\\":\\n return \\\"stats\\\"\\n elif query == \\\"agencyList\\\":\\n return query_url + \\\"agencyList\\\"\\n\\n for i in range(index, len(routers), 1):\\n try:\\n last_query_point = str(query_points[i - index])\\n except:\\n pass\\n query_url += last_query_point + str(routers[i])\\n\\n return query_url\",\n \"def url(vmanage_host,vmanage_port,api):\\r\\n \\\"\\\"\\\" function to get the url provide api endpoint \\\"\\\"\\\"\\r\\n \\r\\n return f\\\"https://{vmanage_host}:{vmanage_port}{api}\\\"\",\n \"def __create_routes__(self):\\n self.app.add_url_rule('/', 'main_page', self.main_page)\\n self.app.add_url_rule('/day', 'day', self.get_current_iteration, methods=['GET'])\\n self.app.add_url_rule('/traders', 'traders', self.register_trader, methods=['POST'])\\n self.app.add_url_rule('/traders/<id>', 'trader', self.get_trader_state, methods=['GET'])\\n self.app.add_url_rule('/stock/price', 'price', self.get_stock_price, methods=['GET'])\\n self.app.add_url_rule('/stock/history', 'history', self.get_stock_price_history, methods=['GET'])\\n self.app.add_url_rule('/stock/buy', 'buy', self.place_buy_order, methods=['POST'])\\n self.app.add_url_rule('/stock/sell', 'sell', self.place_sell_order, methods=['POST'])\\n self.app.add_url_rule('/simulation/step', 'step', self.market_session_step, methods=['POST'])\\n self.app.add_url_rule('/simulation/run', 'run', self.run_simulation, methods=['POST'])\",\n \"def get_urls(self):\\n info = self.model._meta.app_label, self.model._meta.model_name\\n\\n return super().get_urls() + [\\n path(\\\"ajax\\\", self.callback, name=\\\"%s_%s_ajax\\\" % info),\\n path(\\\"layer\\\", self.get_layer, name=\\\"%s_%s_layer\\\" % info)\\n ]\",\n \"def list_routes():\\n import urllib\\n output = []\\n for rule in app.url_map.iter_rules():\\n options = {}\\n for arg in rule.arguments:\\n options[arg] = \\\"[{0}]\\\".format(arg)\\n\\n methods = ','.join(rule.methods)\\n url = url_for(rule.endpoint, **options)\\n line = urllib.parse.unquote(\\n \\\"{:35s} {:35s} {}\\\".format(\\n rule.endpoint,\\n methods,\\n url\\n )\\n )\\n output.append(line)\\n\\n for line in sorted(output):\\n print(line)\",\n \"def _create_request_url():\\n url = 'http'\\n if _config['save']:\\n url += 's'\\n url += '://{}:{}/move'.format(_config['ip'], _config['port'])\\n return url\",\n \"def construct_url(self):\\n path = [self.path]\\n path.extend([str(x) for x in self.params])\\n\\n url = self.client.base_url + '/'.join(x for x in path if x)\\n query = self.kwargs.get('query')\\n\\n if query:\\n # Dict -> List\\n if type(query) is dict:\\n query = query.items()\\n\\n # Remove items with `None` value\\n query = [\\n (k, v) for (k, v) in query\\n if v is not None\\n ]\\n\\n # Encode query, append to URL\\n url += '?' + urlencode(query)\\n\\n return url\",\n \"def build_links(self):\\n xygrid = self.xymap.xygrid\\n\\n # we must use the xygrid coordinates\\n x, y = self.x, self.y\\n\\n # scan in all directions for links\\n for direction, (dx, dy) in MAPSCAN.items():\\n\\n lx, ly = x + dx, y + dy\\n\\n if lx in xygrid and ly in xygrid[lx]:\\n link = xygrid[lx][ly]\\n\\n # just because there is a link here, doesn't mean it has a\\n # connection in this direction. If so, the `end_node` will be None.\\n end_node, weight, steps = link.traverse(REVERSE_DIRECTIONS[direction])\\n\\n if end_node:\\n # the link could be followed to an end node!\\n\\n self.first_links[direction] = link\\n\\n # check the actual direction-alias to use, since this may be\\n # different than the xygrid cardinal directions. There must be\\n # no duplicates out of this node or there will be a\\n # multi-match error later!\\n first_step_name = steps[0].direction_aliases.get(direction, direction)\\n if first_step_name in self.closest_neighbor_names:\\n raise MapParserError(\\n f\\\"has more than one outgoing direction '{first_step_name}'. \\\"\\n \\\"All directions out of a node must be unique.\\\",\\n self,\\n )\\n self.closest_neighbor_names[first_step_name] = direction\\n\\n node_index = end_node.node_index\\n self.weights[node_index] = weight\\n self.links[direction] = end_node\\n # this is useful for map building later - there could be multiple\\n # links tied together until getting to the node\\n self.xy_steps_to_node[direction] = steps\\n\\n # used for building the shortest path. Note that we store the\\n # aliased link directions here, for quick display by the\\n # shortest-route solver\\n shortest_route = self.shortest_route_to_node.get(node_index, (\\\"\\\", [], BIGVAL))[\\n 2\\n ]\\n if weight < shortest_route:\\n self.shortest_route_to_node[node_index] = (first_step_name, steps, weight)\",\n \"def test_url_helper_coordinates():\\n urlh = URLHelper()\\n args = []\\n kwargs = {\\\"coordinates\\\": \\\"210.80242917 54.348753\\\"}\\n url = urlh.build_url(*args, **kwargs)\\n assert url == \\\"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/ra=210.802429/dec=54.348753\\\"\",\n \"def _generate_url(self, **kwargs):\\n path = self.url_path.format(**kwargs)\\n return self.poolbot.generate_url(path)\",\n \"def generate_URLs(county_codes=range(1, 59), city_codes=range(59, 507), county_level=False):\\n\\tDATA_PATH = \\\"https://www2.calrecycle.ca.gov/WasteCharacterization/ResidentialStreams?cy={}&lg={}&mt=0&bg=0&mtf=0\\\"\\n\\n\\tpossible_URLs = []\\n\\tfor county in county_codes:\\n\\t if county_level:\\n\\t possible_URLs.append(DATA_PATH.format(county, county+1000))\\n\\t else:\\n\\t for city in city_codes:\\n\\t possible_URLs.append(DATA_PATH.format(county, city))\\n\\treturn possible_URLs\",\n \"def request_url(request):\\n \\n shot = request.GET['shot']\\n path = request.GET['path']\\n tree = request.GET['tree']\\n\\n xml_elmt = '{http://h1svr.anu.edu.au/}dataurlmap'\\n lang_attr = {'{http://www.w3.org/XML/1998/namespace}lang': 'en'}\\n url_xml = etree.Element(xml_elmt, attrib=lang_attr)\\n \\n shot_number = etree.SubElement(url_xml, 'shot_number', attrib={})\\n shot_number.text = shot\\n data_path = etree.SubElement(url_xml, 'path', attrib={})\\n data_path.text = path\\n data_tree = etree.SubElement(url_xml, 'tree', attrib={})\\n data_tree.text = tree\\n\\n url_processor = URLProcessor(shot=int(shot), tree=tree, path=path)\\n url = url_processor.get_url()\\n url_el = etree.SubElement(url_xml, 'url', attrib={})\\n url_el.text = url\\n\\n return HttpResponse(etree.tostring(url_xml),\\n mimetype='text/xml; charset=utf-8')\",\n \"def __http_build_url(self, url_path):\\n\\n return '{}://{}{}'.format(_GOVEE_API_PROTOCOL, _GOVEE_API_HOST, url_path)\",\n \"def url():\\n ...\",\n \"def _prepare_url(self):\\n\\n base_url = '{}://{}{}'.format(\\n self.client.protocol, self.client.base_url, self.api_path\\n )\\n url_parts = '/'.join(\\n [part for part in self.parameters[constants.RequestConst.PATH]]\\n )\\n\\n if url_parts:\\n final_url = '{}/{}'.format(base_url, url_parts)\\n else:\\n final_url = base_url\\n\\n if self.method == constants.RequestConst.GET:\\n params = self.parameters[constants.RequestConst.QUERY]\\n for param, value in params.items():\\n if isinstance(value, list):\\n params[param] = ','.join(value)\\n elif isinstance(value, dict):\\n params[param] = ','.join([f'{k}:{v}' for k, v in value])\\n\\n url_query = '?' + '&'.join([f'{k}={v}' for k, v in params.items()])\\n final_url = '{}{}'.format(final_url, url_query)\\n\\n self.debug.ok('final url', final_url)\\n\\n return final_url\",\n \"def get_url(self):\\n url = \\\"https://api.darksky.net/forecast/{}/{},{}?lang={}&units={}\\\"\\\\\\n .format(str(self.key),\\n str(self.lat),\\n str(self.lng),\\n self.lang,\\n self.units)\\n addons = \\\"\\\"\\n if self.exclude is not None:\\n addons += \\\"&exclude=\\\" + \\\",\\\".join(self.exclude)\\n if self.extend is not None:\\n addons += \\\"&extend=\\\" + \\\",\\\".join(self.extend)\\n\\n return url + addons\",\n \"def build_call(*args):\\n call = 'http://atlas.media.mit.edu/'\\n for val in args:\\n call += str(val) + '/'\\n return call\",\n \"def start_urls(self):\\n if self.agency_doc_id or self.dept_doc_id:\\n agency_doc_id = self.agency_doc_id\\n if isinstance(agency_doc_id, list):\\n agency_doc_id = agency_doc_id[0]\\n return [\\n \\\"https://detroitmi.gov/documents?{}={}&{}={}\\\".format(\\n self.doc_query_param_dept,\\n self.dept_doc_id,\\n self.doc_query_param,\\n agency_doc_id or \\\"\\\",\\n )\\n ]\\n else:\\n return [self.get_event_start_url()]\",\n \"def gen_url(section):\\n urls = []\\n urls.append('https://ia800500.us.archive.org/22/items/stackexchange/' + section + '.stackexchange.com.7z')\\n urls.append('https://ia800500.us.archive.org/22/items/stackexchange/' + section + '.7z')\\n return urls\",\n \"def _generate_url(self, endpoint:str, params:Dict[str, str]=None) -> str:\\n if params:\\n return f\\\"{self.BASE_URL}/{self._api_version}{endpoint}?{urlencode(params)}\\\"\\n return f\\\"{self.BASE_URL}/{self._api_version}{endpoint}\\\"\",\n \"def generate_links():\\n start_url = 'https://twigserial.wordpress.com/'\\n base_url = start_url + 'category/story/'\\n tree = etree.HTML(requests.get(start_url).text)\\n xpath = './/*/option[@class=\\\"level-2\\\"]/text()'\\n return [base_url + suffix.strip() for suffix in tree.xpath(xpath)]\",\n \"def create_url_rules(self):\\n\\n def p(prefix, route):\\n \\\"\\\"\\\"Prefix a route with the URL prefix.\\\"\\\"\\\"\\n return f\\\"{prefix}{route}\\\"\\n\\n routes = self.config.routes\\n return [\\n route(\\n \\\"GET\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"list\\\"]),\\n self.search\\n ),\\n route(\\n \\\"POST\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"list\\\"]),\\n self.create\\n ),\\n route(\\n \\\"GET\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]),\\n self.read\\n ),\\n route(\\n \\\"PUT\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]),\\n self.update\\n ),\\n route(\\n \\\"DELETE\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]),\\n self.delete\\n ),\\n route(\\n \\\"GET\\\",\\n p(routes[\\\"user-prefix\\\"], routes[\\\"list\\\"]),\\n self.search_user_communities\\n ),\\n route(\\n \\\"POST\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]) + '/rename',\\n self.rename\\n ),\\n route(\\n \\\"GET\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]) + '/logo',\\n self.read_logo\\n ),\\n route(\\n \\\"PUT\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]) + '/logo',\\n self.update_logo\\n ),\\n route(\\n \\\"DELETE\\\",\\n p(routes[\\\"communities-prefix\\\"], routes[\\\"item\\\"]) + '/logo',\\n self.delete_logo\\n ),\\n ]\",\n \"def __get_url(cls, url):\\n url = url + AdvertCoordinationAdaptor.BASE_URL_QUERY_STRING\\n return url\",\n \"def create_url(path, controller_ip=DNAC):\\n print(\\\"3\\\")\\n return \\\"https://%s:%s/api/v1/%s\\\" % (controller_ip, DNAC_PORT, path)\",\n \"def build_band_urls(scene, bands):\\n return [band_url(scene, band) for band in bands]\",\n \"def create_query_url(self):\\n self.__log('Starting to create the query URL.')\\n query_url = self.config['API_URI']\\n for key, value in self.options.items():\\n if value:\\n if query_url == self.config['API_URI']:\\n query_url = query_url + str(key) + \\\"=\\\" + str(value)\\n else:\\n query_url = query_url + \\\"&\\\" + str(key) + \\\"=\\\" + str(value)\\n query_url = query_url.replace(' ', '%20')\\n self.__log(f'Done creating query url. URL to query: \\\"{query_url}\\\"')\\n return query_url\",\n \"def get_url(self):\\n # Replace erddapy get_download_url()\\n # We need to replace it to better handle http responses with by-passing the _check_url_response\\n # https://github.com/ioos/erddapy/blob/fa1f2c15304938cd0aa132946c22b0427fd61c81/erddapy/erddapy.py#L247\\n\\n # First part of the URL:\\n protocol = self.erddap.protocol\\n dataset_id = self.erddap.dataset_id\\n response = self.erddap.response\\n url = f\\\"{self.erddap.server}/{protocol}/{dataset_id}.{response}?\\\"\\n\\n # Add variables to retrieve:\\n self.erddap.variables = (\\n self._minimal_vlist\\n ) # Define the list of variables to retrieve\\n variables = self.erddap.variables\\n variables = \\\",\\\".join(variables)\\n url += f\\\"{variables}\\\"\\n\\n # Add constraints:\\n self.define_constraints() # Define constraint to select this box of data (affect self.erddap.constraints)\\n constraints = self.erddap.constraints\\n _constraints = copy.copy(constraints)\\n for k, v in _constraints.items():\\n if k.startswith(\\\"time\\\"):\\n _constraints.update({k: parse_dates(v)})\\n _constraints = quote_string_constraints(_constraints)\\n _constraints = \\\"\\\".join([f\\\"&{k}{v}\\\" for k, v in _constraints.items()])\\n url += f\\\"{_constraints}\\\"\\n\\n # Last part:\\n url += '&distinct()&orderBy(\\\"time,pres\\\")'\\n return url\",\n \"def build_request_url(symbol, start_date, end_date):\\n pass\",\n \"def _url_map(self):\\n return Map([\\n Rule('/init', endpoint='init'),\\n Rule('/op/<name>', endpoint='op'),\\n Rule('/handler/<name>', endpoint='handler'),\\n Rule('/hook/<name>', endpoint='hook'),\\n Rule('/provider/<name>/<action>', endpoint='provider'),\\n Rule('/timer/<name>', endpoint='timer'),\\n ])\",\n \"def get_routes():\\n output = [f'{\\\"S. No.\\\":6}\\\\t{\\\"Endpoint\\\":50}\\\\t{\\\"Method\\\":8}\\\\n']\\n\\n for index, rule in enumerate(app.url_map.iter_rules()):\\n for i, method in enumerate(rule.methods):\\n output.append(f'{index + 1 if i == 0 else \\\"\\\":<6}\\\\t{rule.rule:50}\\\\t{method:10}')\\n\\n try:\\n output.append(f'\\\\n{eval(rule.endpoint).__doc__}\\\\n')\\n except NameError:\\n output.append('\\\\n')\\n\\n return Response('\\\\n'.join(output), 200, mimetype='text/plain')\",\n \"def home():\\n return (\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/<start><br/>\\\"\\n f\\\"/api/v1.0/<start>/<end>\\\"\\n \\n )\",\n \"def url(request):\\n URL = namedtuple('URL', ['mainnet', 'testnet'])\\n\\n # For actual trading and market data, the mainnet URL will be used:\\n # When developing application, the testnet URL should be used:\\n url = URL(mainnet=\\\"https://api.switcheo.network/v2/\\\", testnet=\\\"https://test-api.switcheo.network/v2/\\\")\\n\\n def tear_down():\\n # clean up here\\n pass\\n\\n request.addfinalizer(tear_down)\\n return url\",\n \"def test_url_helper_radius():\\n urlh = URLHelper()\\n args = []\\n kwargs = {\\\"radius\\\": \\\"0.4d\\\"}\\n url = urlh.build_url(*args, **kwargs)\\n assert url == \\\"https://archive.gemini.edu/jsonsummary/notengineering/NotFail/sr=0.400000d\\\"\",\n \"def index():\\n g.data['api_version'] = API_VERSION\\n g.data['apilib_version'] = API_VERSION\\n g.data['oar_version'] = VERSION\\n g.data['links'] = []\\n #endpoints = ('resources', 'jobs', 'config', 'admission_rules')\\n endpoints = ('resources', 'jobs')\\n for endpoint in endpoints:\\n g.data['links'].append({\\n 'rel': 'collection',\\n 'href': url_for('%s.index' % endpoint),\\n 'title': endpoint,\\n })\",\n \"def makeRouteRequest(latLongs):\\n global headersGlobal, routeURL_synchronous # get global variables\\n\\n key = variables.bingMapsAPIKey # api key\\n # construct the URL\\n url = routeURL_synchronous + \\\"wp.0=\\\" + str(latLongs[0][0]) + \\\",\\\" + str(latLongs[0][1]) + \\\"&wp.1=\\\" + str(\\n latLongs[1][0]) + \\\",\\\" + str(latLongs[1][1]) + \\\"&key=\\\" + key\\n\\n request = requests.get(url, headers=headersGlobal) # make the request\\n return request # return the request\",\n \"def buildSFOUrls(jd_start, jd_stop):\\n url_list = []\\n time_list = ['03z', '09z', '15z', '21z']\\n delta = jd_stop-jd_start\\n for i in range((delta.days)+1):\\n model_file_date = jd_start + timedelta(days=i)\\n base_url = ('http://opendap.co-ops.nos.noaa.gov/'\\n 'thredds/dodsC/NOAA/SFBOFS/MODELS/')\\n val_month, val_year, val_day = '', '', ''\\n # Month.\\n if model_file_date.month < 10:\\n val_month = \\\"0\\\" + str(model_file_date.month)\\n else:\\n val_month = str(model_file_date.month)\\n # Year.\\n val_year = str(model_file_date.year)\\n # Day.\\n if model_file_date.day < 10:\\n val_day = \\\"0\\\" + str(model_file_date.day)\\n else:\\n val_day = str(model_file_date.day)\\n file_name = '/nos.sfbofs.stations.nowcast.'\\n file_name += val_year + val_month + val_day\\n for t in time_list:\\n t_val = '.t' + t + '.nc'\\n url_list.append(base_url + val_year + val_month +\\n file_name + t_val)\\n return url_list\",\n \"def init_urls(self):\\n url = 'http://www.lagou.com/'\\n for ip_info in self.col.find(no_cursor_timeout=True):\\n ip, port = ip_info['ip'], ip_info['port']\\n if ip and port:\\n self.urls.append((url, ip, port)) # tuple\",\n \"def urls(self):\\n days = ['sun', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', ]\\n url = 'http://www2.nngov.com/newport-news/offenses/%stxt.htm'\\n return [url % day for day in days]\",\n \"def _create_api_ulr_list(self) -> List[str]:\\n api = Setup.pickpoint_api\\n return [\\n f\\\"https://api.pickpoint.io/v1/reverse/?key={api}&lat={lat}&lon={lon}\\\"\\n f\\\"&accept-language=en-US\\\"\\n for lat, lon in self.locations\\n ]\",\n \"def urls(self) -> list[str]:\\r\\n ...\",\n \"def send_request(origin_addresses, dest_addresses, api):\\n def build_address_str(addresses):\\n # Build a pipe-separated string of addresses\\n address_str = ''\\n for i in range(len(addresses) - 1):\\n address_str += addresses[i] + '|'\\n address_str += addresses[-1]\\n return address_str\\n\\n request = 'https://maps.googleapis.com/maps/api/distancematrix/json?units=imperial'\\n origin_address_str = build_address_str(origin_addresses)\\n dest_address_str = build_address_str(dest_addresses)\\n request = request + '&origins=' + origin_address_str + '&destinations=' + \\\\\\n dest_address_str + '&key=' + api\\n jsonResult = urllib.request.urlopen(request).read().decode(\\\"utf-8\\\")\\n response = json.loads(jsonResult)\\n return response\",\n \"def test_client_build_url():\\n eq_(\\\"{0}/{1}\\\".format(client.BASE_URL, \\\"v1/charges/\\\"), client.build_url(\\\"v1/charges/\\\"))\",\n \"def get_url(phrase, prefix='all', start=0, max_results=10, sort_by='relevance', sort_order='descending'):\\n base_url = 'http://export.arxiv.org/api/query?search_query='\\n url = base_url + \\\\\\n prefix+':'+phrase + \\\\\\n '&start='+str(start) + \\\\\\n '&max_results='+str(max_results) + \\\\\\n '&sortBy='+sort_by + \\\\\\n '&sortOrder='+sort_order\\n return url\",\n \"def generate_urls(date: datetime.date) -> List[str]:\\n date_string = date.strftime(\\\"%B-%-d-%Y\\\").lower()\\n url_veggie = (\\n f\\\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\\\"\\n f\\\"?slug={date_string}-veggie&type[]=page&type[]=topic&type[]=story&\\\"\\n f\\\"type[]=product&type[]=collection&type[]=event&type[]=menu&\\\"\\n f\\\"type[]=person&type[]=recipe\\\"\\n )\\n url_tday = (\\n f\\\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\\\"\\n f\\\"?slug={date_string}-thoughtful-t-day&type[]=page&type[]=topic&type[]=story&\\\"\\n f\\\"type[]=product&type[]=collection&type[]=event&type[]=menu&\\\"\\n f\\\"type[]=person&type[]=recipe\\\"\\n )\\n url = (\\n f\\\"https://trouble.tools/506/wp-json/wp/v2/multiple-post-type\\\"\\n f\\\"?slug={date_string}&type[]=page&type[]=topic&type[]=story&\\\"\\n f\\\"type[]=product&type[]=collection&type[]=event&type[]=menu&\\\"\\n f\\\"type[]=person&type[]=recipe\\\"\\n )\\n return [url_veggie, url_tday, url]\",\n \"def _route_chunk(data, host_url, annotations='duration', retries=10, extra_params=None):\\n\\t# offsets are used to make correct indice of the result dataframe\\n\\tsources, destinations, sources_offset, destinations_offset = data\\n\\tsources_count = len(sources)\\n\\tdestinations_count = len(destinations)\\n\\n\\t# OSRM takes all points as one list, and then numbers of sources & dests in it\\n\\tall_points = sources + destinations\\n\\tencoded = encode_poly([(p.y, p.x) for p in all_points])\\n\\n\\t# numerate sources & dests. sources come first\\n\\tsource_numbers = ';'.join(map(str, range(sources_count)))\\n\\tdestination_numbers = ';'.join(map(str,\\n\\t\\trange(sources_count, sources_count + destinations_count)))\\n\\n\\n\\textra_params = extra_params or {}\\n\\tparams = {\\n\\t\\t'sources': source_numbers,\\n\\t\\t'destinations': destination_numbers,\\n\\t\\t'generate_hints': 'false',\\n\\t\\t'annotations': annotations,\\n\\t\\t**extra_params\\n\\t}\\n\\n\\tencoded_params = urllib.parse.quote_plus(urllib.parse.urlencode(params))\\n\\t# if we pass url and params separately to requests.get, it will make a malformed URL\\n\\tencoded_url = f'{host_url}/table/v1/driving/polyline({encoded})?{encoded_params}'\\n\\tresp = get_retry(encoded_url, {}, retries)\\n\\n\\tif resp.status_code != 200:\\n\\t\\traise RuntimeError(f'OSRM server responded with {resp.status_code} code. Content: {resp.content}')\\n\\n\\tresp_data = resp.json()\\n\\tif resp_data.get('code', 'Ok') != 'Ok':\\n\\t\\traise RuntimeError(f'OSRM server responded with error message: {resp_data[\\\"message\\\"]}')\\n\\n\\t# if 'duration' is requested, then take resp_data['durations'], or resp_data['distances'] if distances.\\n\\t# also, 'duration,distance' might be requested, then take both and concatenate results (= join columns)\\n\\tresults = []\\n\\t\\n\\tfor key in annotations.split(','):\\n\\t\\tdf = pd.DataFrame(resp_data[f'{key}s']).reset_index().rename(columns={'index': 'source'}).melt(id_vars='source', var_name='destination', value_name=key)\\n\\t\\tdf[key] = df[key].astype(float)\\n\\t\\tif len(results) > 0:\\n\\t\\t\\t# only append the data column\\n\\t\\t\\tresults.append(df[[key]])\\n\\t\\telse:\\n\\t\\t\\tresults.append(df)\\n\\n\\tresult_df = pd.concat(results, axis=1)\\n\\n\\t# snapping distances\\n\\tresult_df['source_snap'] = result_df.source.map(pd.DataFrame(resp_data['sources'])['distance'])\\n\\tresult_df['destination_snap'] = result_df.destination.map(pd.DataFrame(resp_data['destinations'])['distance'])\\n\\n\\t# instead of join/merge lookup\\n\\tresult_df['geometry'] = result_df['source'].map({i: g for i, g in enumerate(sources)})\\n\\tresult_df['geometry_dest'] = result_df['destination'].map({i: g for i, g in enumerate(destinations)})\\n\\n\\t# shift back by the given offset\\n\\tresult_df['destination'] = result_df['destination'].astype(int) + destinations_offset\\n\\tresult_df['source'] = result_df['source'].astype(int) + sources_offset\\n\\treturn result_df\",\n \"def build_api_url(project, method, base_url):\\n return API_URL_TEMPLATE.format(\\n api_base=base_url, api_version=API_VERSION, project=project, method=method\\n )\",\n \"def _build_url(self, service, resource_type, parameters={}):\\n # authenticated dataselect queries have different target URL\\n if self.user is not None:\\n if service == \\\"dataselect\\\" and resource_type == \\\"query\\\":\\n resource_type = \\\"queryauth\\\"\\n return build_url(self.base_url, service, self.major_versions[service],\\n resource_type, parameters,\\n service_mappings=self._service_mappings,\\n subpath=self.url_subpath)\",\n \"def construct_url(self,*path):\\n base = self.request.protocol+\\\"://\\\"+self.request.host+\\\"/\\\"\\n return base+\\\"/\\\".join(path)\",\n \"def generate_url(self, campaign_id):\\n pass\",\n \"def home():\\n return (\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/<start><br/>\\\"\\n f\\\"/api/v1.0/<start>/<end><br/>\\\"\\n )\",\n \"def get_proxy_url(self, request, service, url):\\n params = None\\n logger.debug(\\n \\\"Enter MyUWRestProxyView service: {}, url: {}, GET: {}\\\".format(\\n service, url, request.POST))\\n\\n if service == \\\"book\\\":\\n url = \\\"uw/json_utf8_202007.ubs\\\"\\n url = \\\"{}?quarter={}&sln1={}&returnlink=t\\\".format(\\n \\\"uw/json_utf8_202007.ubs\\\",\\n request.POST[\\\"quarter\\\"],\\n request.POST[\\\"sln1\\\"])\\n elif service == \\\"grad\\\":\\n params = self.format_params(request)\\n elif service == \\\"hfs\\\":\\n url = \\\"myuw/v1/{}\\\".format(request.POST[\\\"uwnetid\\\"])\\n elif re.match(r'^iasystem', service):\\n if url.endswith('/evaluation'):\\n index = url.find('/')\\n service = 'iasystem_' + url[:index]\\n index += 1\\n url = url[index:]\\n params = self.format_params(request)\\n elif service == \\\"myplan\\\":\\n url = \\\"plan/v1/{},{},1,{}\\\".format(\\n request.POST[\\\"year\\\"],\\n request.POST[\\\"quarter\\\"],\\n request.POST[\\\"uwregid\\\"])\\n elif service == \\\"sws\\\":\\n if \\\"advisers\\\" == url:\\n url = \\\"student/v5/person/{}/advisers.json\\\".format(\\n request.POST[\\\"uwregid\\\"])\\n elif \\\"degree\\\" == url:\\n url = \\\"student/v5/person/{}/degree.json?deg_status=all\\\".format(\\n request.POST[\\\"uwregid\\\"])\\n elif \\\"notices\\\" == url:\\n url = \\\"student/v5/notice/{}.json\\\".format(\\n request.POST[\\\"uwregid\\\"])\\n elif service == \\\"upass\\\":\\n url = \\\"upassdataws/api/person/v1/membershipstatus/{}\\\".format(\\n request.POST[\\\"uwnetid\\\"])\\n elif service == \\\"uwnetid\\\":\\n if \\\"password\\\" == url:\\n url = \\\"nws/v1/uwnetid/{}/password\\\".format(\\n request.POST[\\\"uwnetid\\\"])\\n elif \\\"subscription\\\" == url:\\n url = \\\"nws/v1/uwnetid/{}/subscription/60,64,105\\\".format(\\n request.POST[\\\"uwnetid\\\"])\\n else:\\n service, url, params = super().get_proxy_url(request, service, url)\\n\\n logger.debug(\\n \\\"Exit MyUWRestProxyView url: {}\\\".format(url))\\n return service, url, params\",\n \"def _get_url(self, absolute):\",\n \"def _construct_url(self, endpoint):\\n return self.base_url + self.api_path + endpoint.strip('/')\",\n \"def _urlBuilder(dateString, version, table='events', translation=False):\\r\\n\\r\\n if version == 2:\\r\\n base = \\\"http://data.gdeltproject.org/gdeltv2/\\\"\\r\\n\\r\\n if version == 1:\\r\\n base = \\\"http://data.gdeltproject.org/\\\"\\r\\n\\r\\n if table == \\\"events\\\":\\r\\n if version == 1:\\r\\n base += 'events/'\\r\\n if not translation:\\r\\n caboose = \\\".export.CSV.zip\\\"\\r\\n else:\\r\\n caboose = \\\".translation.export.CSV.zip\\\"\\r\\n elif table == \\\"mentions\\\":\\r\\n if not translation:\\r\\n caboose = \\\".mentions.CSV.zip\\\"\\r\\n else:\\r\\n caboose = \\\".translation.mentions.CSV.zip\\\"\\r\\n elif table == \\\"gkg\\\":\\r\\n if version == 1:\\r\\n base += 'gkg/'\\r\\n if isinstance(dateString,str):\\r\\n comp = _testdate(dateString)\\r\\n if comp < parse('2013 Apr 1'):\\r\\n raise Exception('GDELT 1.0 Global Knowledge Graph requires dates greater'\\r\\n ' than or equal to April 1 2013')\\r\\n elif isinstance(dateString, list) or isinstance(dateString,\\r\\n np.ndarray):\\r\\n if not (np.all(list(\\r\\n map(\\r\\n lambda x: x > parse('2013 04 01'), list(\\r\\n map(\\r\\n _testdate, dateString)))))):\\r\\n raise Exception('GDELT 1.0 Global Knowledge Graph requires dates greater'\\r\\n ' than or equal to April 1 2013')\\r\\n\\r\\n\\r\\n if not translation:\\r\\n caboose = \\\".gkg.csv.zip\\\"\\r\\n else:\\r\\n caboose = \\\".translation.gkg.csv.zip\\\"\\r\\n else: # pragma: no cover\\r\\n raise ValueError('You entered an incorrect GDELT table type.'\\r\\n ' Choose between \\\\\\\"events\\\\\\\",\\\\\\\"mentions\\\\\\\",'\\r\\n 'and \\\\\\\"gkg\\\\\\\".')\\r\\n\\r\\n\\r\\n if isinstance(dateString, list) is True or isinstance(dateString,\\r\\n np.ndarray) is True:\\r\\n # print(\\\"This is before any changes {}\\\".format(dateString))\\r\\n newdate = []\\r\\n olddateString = dateString\\r\\n date=dateString\\r\\n for l in date:\\r\\n if len(l) == 4: # pragma: no cover\\r\\n test = (str(datetime.datetime.strptime(l, '%Y')))\\r\\n newdate.append(test)\\r\\n elif len(l) == 6: # pragma: no cover\\r\\n test = str(datetime.datetime.strptime(l, '%Y%m'))\\r\\n newdate.append(test)\\r\\n else:\\r\\n\\r\\n test = str(parse(str(l)))\\r\\n newdate.append(test)\\r\\n\\r\\n if version ==1:\\r\\n if table != 'gkg':\\r\\n # print(base)\\r\\n base\\r\\n # print(\\\"After {}\\\".format(base))\\r\\n\\r\\n if not (np.all(list(\\r\\n map(\\r\\n lambda x: x > parse('2013 04 01'), list(\\r\\n map(\\r\\n _testdate, dateString)))))): # pragma: no cover\\r\\n\\r\\n return (list(\\r\\n map(lambda x: base + x + \\\".zip\\\" if _testdate(\\r\\n x).date() < parse(\\r\\n '2013 04 01').date() else base + x + caboose,\\r\\n dateString)))\\r\\n\\r\\n else:\\r\\n\\r\\n return list(map(lambda x: base + x + caboose, olddateString))\\r\\n\\r\\n elif isinstance(dateString, str) is True or len(dateString) == 1:\\r\\n\\r\\n if version == 1:\\r\\n if table=='events':\\r\\n if len(dateString) == 4:\\r\\n comp = datetime.datetime.strptime(dateString,'%Y')\\r\\n elif len(dateString) == 6:\\r\\n comp = datetime.datetime.strptime(dateString, '%Y%m')\\r\\n else:\\r\\n comp = parse(dateString)\\r\\n if comp < parse('2013 Apr 01'):\\r\\n caboose = \\\".zip\\\"\\r\\n elif table == 'events':\\r\\n caboose = \\\".export.CSV.zip\\\"\\r\\n\\r\\n if isinstance(dateString, list) is True or isinstance(\\r\\n dateString, np.ndarray) is True: # pragma: no cover\\r\\n dateString = dateString[0]\\r\\n if parse(dateString[0]) < parse('2013 Apr 01'):\\r\\n caboose = \\\".zip\\\"\\r\\n\\r\\n return base + dateString + caboose\",\n \"def home():\\n return (\\n f\\\"Available Routes:<br/>\\\"\\n f\\\"/api/v1.0/precipitation<br/>\\\"\\n f\\\"/api/v1.0/stations<br/>\\\"\\n f\\\"/api/v1.0/tobs<br/>\\\"\\n f\\\"/api/v1.0/start_date(yyyy-mm-dd)<br/>\\\"\\n f\\\"/api/v1.0/start_date(yyyy-mm-dd)/end_date(yyyy-mm-dd)<br/>\\\")\",\n \"def apiurl (self):\\n return Links.createAPIURL (\\n '/boards.json'\\n )\",\n \"def create_url(model, trips_year):\\n return model.create_url(trips_year)\",\n \"def build_url(self, dict_args_in_out=None):\\n if dict_args_in_out is None:\\n dict_args_in_out = {}\\n\\n url = dict_args_in_out.pop('base_url', None) or ''\\n url += '/%s' % self.collection_key\\n\\n # do we have a specific entity?\\n entity_id = dict_args_in_out.pop('%s_id' % self.key, None)\\n if entity_id is not None:\\n url += '/%s' % entity_id\\n\\n return url\",\n \"def barbican_url(self):\",\n \"def __build_url(path, api_site_parameter, **params):\\n \\n query = [\\\"%s=%s\\\" % (key, params[key]) for key in params if (params[key] or key == 'pagesize') ]\\n query_string = \\\"&\\\".join(query)\\n url = \\\"%s/%s/%s?\\\" % (__api_endpoint, __api_version, path)\\n url += query_string\\n return url\",\n \"def build_details_url(self, params={}):\\n\\n if 'url' in params:\\n url = params['url']\\n url += '?page=' + str(int(params['page'])) + '&sort=' + str(params['sort'])\\n return url\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.662632","0.6459529","0.64105844","0.63785255","0.61424583","0.6120072","0.61160785","0.5975166","0.5922255","0.5866318","0.58486396","0.58353645","0.5809004","0.5791701","0.5777878","0.57720447","0.5690597","0.5641834","0.56298447","0.5613718","0.5601663","0.55605197","0.5559404","0.5547739","0.5547522","0.5544924","0.55438316","0.5542241","0.55405","0.55054396","0.55028754","0.54910916","0.5490829","0.5487979","0.54871106","0.5469326","0.5469081","0.54675734","0.546649","0.5456066","0.5449144","0.54306555","0.5430085","0.5406658","0.54038066","0.5401647","0.5397262","0.53944755","0.5389141","0.5380075","0.5379937","0.53714424","0.5369242","0.5367165","0.5366422","0.53633994","0.534354","0.5326041","0.5314162","0.5308815","0.5290542","0.52891654","0.5285278","0.5271261","0.5269178","0.5261047","0.5236149","0.52340853","0.5233969","0.5233331","0.523098","0.5217135","0.5212033","0.52102154","0.52099824","0.5201717","0.52012455","0.5193578","0.51777923","0.51710373","0.51686746","0.51665545","0.5161726","0.5141479","0.5140429","0.5132741","0.5129454","0.51271445","0.51269066","0.5123357","0.511854","0.5107071","0.51038617","0.5093546","0.50871694","0.50820607","0.5076095","0.5075607","0.50754845","0.50738704"],"string":"[\n \"0.662632\",\n \"0.6459529\",\n \"0.64105844\",\n \"0.63785255\",\n \"0.61424583\",\n \"0.6120072\",\n \"0.61160785\",\n \"0.5975166\",\n \"0.5922255\",\n \"0.5866318\",\n \"0.58486396\",\n \"0.58353645\",\n \"0.5809004\",\n \"0.5791701\",\n \"0.5777878\",\n \"0.57720447\",\n \"0.5690597\",\n \"0.5641834\",\n \"0.56298447\",\n \"0.5613718\",\n \"0.5601663\",\n \"0.55605197\",\n \"0.5559404\",\n \"0.5547739\",\n \"0.5547522\",\n \"0.5544924\",\n \"0.55438316\",\n \"0.5542241\",\n \"0.55405\",\n \"0.55054396\",\n \"0.55028754\",\n \"0.54910916\",\n \"0.5490829\",\n \"0.5487979\",\n \"0.54871106\",\n \"0.5469326\",\n \"0.5469081\",\n \"0.54675734\",\n \"0.546649\",\n \"0.5456066\",\n \"0.5449144\",\n \"0.54306555\",\n \"0.5430085\",\n \"0.5406658\",\n \"0.54038066\",\n \"0.5401647\",\n \"0.5397262\",\n \"0.53944755\",\n \"0.5389141\",\n \"0.5380075\",\n \"0.5379937\",\n \"0.53714424\",\n \"0.5369242\",\n \"0.5367165\",\n \"0.5366422\",\n \"0.53633994\",\n \"0.534354\",\n \"0.5326041\",\n \"0.5314162\",\n \"0.5308815\",\n \"0.5290542\",\n \"0.52891654\",\n \"0.5285278\",\n \"0.5271261\",\n \"0.5269178\",\n \"0.5261047\",\n \"0.5236149\",\n \"0.52340853\",\n \"0.5233969\",\n \"0.5233331\",\n \"0.523098\",\n \"0.5217135\",\n \"0.5212033\",\n \"0.52102154\",\n \"0.52099824\",\n \"0.5201717\",\n \"0.52012455\",\n \"0.5193578\",\n \"0.51777923\",\n \"0.51710373\",\n \"0.51686746\",\n \"0.51665545\",\n \"0.5161726\",\n \"0.5141479\",\n \"0.5140429\",\n \"0.5132741\",\n \"0.5129454\",\n \"0.51271445\",\n \"0.51269066\",\n \"0.5123357\",\n \"0.511854\",\n \"0.5107071\",\n \"0.51038617\",\n \"0.5093546\",\n \"0.50871694\",\n \"0.50820607\",\n \"0.5076095\",\n \"0.5075607\",\n \"0.50754845\",\n \"0.50738704\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7186997"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20182,"cells":{"query":{"kind":"string","value":"Calls all the map methods and returns a tuple with all the info"},"document":{"kind":"string","value":"def get_all_map_info(start, end, transit_mode=None):\n directions = find_directions(start, end, transit_mode)\n distance = find_distance(start, end, transit_mode)\n static_map = find_map(start, end)\n return (distance, directions, static_map)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def map():","def map(self):\r\n pass","def _do_mapping(self):\n pass","def get_data(self) -> Tuple[PoliciesMap, ZonesMap, LinksMap]:\n return self.policies_map, self.zones_map, self.links_map","def _map_fn(self):\n raise NotImplementedError","def map( self ) :\n\n self.readMap( )\n\n return( self.__map )","def applyMapping(self):\n pass","def mapdata():\n return getmapdata(db, MyTable)","def _do_mapping(self):\n\n distro = None\n versions = None\n flavor = None\n\n try:\n distro = self._map_name(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\n flavor = self._map_flavor(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\n versions = self._map_version(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\n return [DistroTuple(distro=distro, version=v, flavor=flavor) for v in versions]\n except:\n log.exception(\n 'Failed to fully construct the mapped distro from: {}, {}, {}'.format(self.from_distro,\n self.from_version,\n self.from_like_distro))\n raise","def map(self, function):\n pass","def udcall_map_next(*args):\n return _ida_hexrays.udcall_map_next(*args)","def call(self) -> List[Dict]:","def get_map(self):\n return self.get_raw_ys()","def after_map(self, map):\n return map","def after_map(self, map):\n return map","def map(z):\n pass","def MAP(self):\n return self.__map","def mapped(self, *args, **kwargs): # real signature unknown\r\n pass","def mapper() -> Callable[[str], Pin]:","def multi_mapping(func_name, arg_value_pairs, module_name = \"__main__\"):\n func, arg_names = get_function_args(module_name = module_name, function_name = func_name)\n \n return list(map(lambda arg_value_pair: call_func_dynamically(function_name = func_name, \n argument_names = arg_names, \n arg_value_pair = arg_value_pair) ,\n arg_value_pairs))","def getMappedInfo(self):\n \n return self.mapped_info","def _map___iter__(self):\n return self.iterkeys()","def receiverMapping():","def udcall_map_second(*args):\n return _ida_hexrays.udcall_map_second(*args)","def _get_mapper_0(model):\n # build the maps\n eids_all = (\n list(model.elements.keys()) +\n list(model.masses.keys()) +\n list(model.rigid_elements.keys())\n )\n eid_map = {eid : eid for eid in eids_all}\n nid_map = {nid : nid for nid in model.point_ids}\n cid_map = {cid : cid for cid in model.coord_ids}\n mid_map = {mid : mid for mid in model.material_ids}\n spc_map = _dicts_key_to_key((model.spcs, model.spcadds))\n mpc_map = _dicts_key_to_key((model.mpcs, model.mpcadds))\n method_map = _dict_key_to_key(model.methods)\n properties_map = _dict_key_to_key(model.properties)\n rigid_elements_map = _dict_key_to_key(model.rigid_elements)\n cmethod_map = _dict_key_to_key(model.cMethods)\n flfact_map = _dict_key_to_key(model.flfacts)\n flutter_map = _dict_key_to_key(model.flutters)\n caero_map = _dict_key_to_key(model.caeros)\n freq_map = _dict_key_to_key(model.frequencies)\n\n dload_map = _dicts_key_to_key((model.dload_entries, model.dloads))\n load_map = _dicts_key_to_key((model.loads, model.load_combinations))\n lseq_map = load_map # wrong???\n temp_map = load_map # wrong???\n\n tstep_map = _dict_key_to_key(model.tsteps)\n tstepnl_map = _dict_key_to_key(model.tstepnls)\n suport1_map = _dict_key_to_key(model.suport1)\n #suport_map = {}\n\n nlparm_map = _dict_key_to_key(model.nlparms)\n #nlpci_map = _dict_key_to_key(model.nlpcis)\n table_sdamping_map = _dict_key_to_key(model.tables_sdamping)\n dconadd_map = _dict_key_to_key(model.dconadds)\n dconstr_map = _dict_key_to_key(model.dconstrs)\n dessub_map = dconadd_map\n for key, value in dconstr_map.items():\n if key in dessub_map:\n raise NotImplementedError()\n dessub_map[key] = value\n dresp_map = _dict_key_to_key(model.dresps)\n gust_map = _dict_key_to_key(model.gusts)\n trim_map = _dict_key_to_key(model.trims)\n tic_map = _dict_key_to_key(model.tics)\n csschd_map = _dict_key_to_key(model.csschds)\n tranfer_function_map = _dict_key_to_key(model.transfer_functions)\n\n mapper = {\n 'elements' : eid_map,\n 'nodes' : nid_map,\n 'coords' : cid_map,\n 'materials' : mid_map,\n 'properties' : properties_map,\n 'rigid_elements': rigid_elements_map,\n 'spcs' : spc_map,\n 'mpcs' : mpc_map,\n 'METHOD' : method_map,\n 'CMETHOD' : cmethod_map,\n 'FLFACT' : flfact_map,\n 'FMETHOD' : flutter_map,\n 'caeros' : caero_map,\n 'FREQUENCY' : freq_map,\n\n 'DLOAD' : dload_map,\n 'LOAD' : load_map,\n 'LOADSET' : lseq_map,\n 'TSTEP' : tstep_map,\n 'TSTEPNL' : tstepnl_map,\n 'SUPORT1' : suport1_map,\n 'NLPARM' : nlparm_map,\n 'SDAMPING' : table_sdamping_map,\n 'DESSUB' : dessub_map,\n 'DESOBJ' : dresp_map,\n 'GUST' : gust_map,\n 'TRIM' : trim_map,\n 'IC' : tic_map,\n 'CSSCHD' : csschd_map,\n 'TFL' : tranfer_function_map,\n #'DESSUB' : dessub_map,\n # bad...\n 'TEMPERATURE(LOAD)' : temp_map,\n 'TEMPERATURE(INITIAL)' : temp_map,\n #'DATAREC' : datarec_map,\n #'ADAPT' : adapt_map,\n #'SUPER' : super_map,\n #'BOUTPUT' : boutput_map,\n #'OUTRCV' : outrcv_map,\n }\n\n return mapper","def getInfo():","def test_core_functionality(self):\n # Test typing\n self.run_map_collection(\n _map_collection=self.example_map\n )","def __call__(self):\n return self._main._values()","def get_map(self):\n return self.map","def get_map(self) -> list:\n return self.map_obstacle","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('ANAP').get('abstractTypes')\n exolinks = globalMap.get('ANAP').get('exolinks')\n\n # DataType GraphicsHandlerType\n currentMap = {}\n abstractTypes['GraphicsHandlerType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'] = currentMap\n loadMaps['ANAP.GraphicsHandlerType'] = currentMap\n currentMap['tag'] = 'ANAP.GraphicsHandlerType'\n currentMap['type'] = 'simple'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'\n currentMap['toStr'] = 'text'\n currentMap['cnvrt'] = 'text'\n\n # Class AnalysisProfile\n currentMap = {}\n abstractTypes['AnalysisProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'] = currentMap\n loadMaps['ANAP.AnalysisProfile'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'analysisProfiles'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AnalysisProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AnalysisProfile.bgColor\n currentMap = {}\n contentMap['bgColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'] = currentMap\n loadMaps['ANAP.AnalysisProfile.bgColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.bgColor'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'\n currentMap['name'] = 'bgColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['default'] = '#FFFFFF'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute AnalysisProfile.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.fgColor\n currentMap = {}\n contentMap['fgColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'] = currentMap\n loadMaps['ANAP.AnalysisProfile.fgColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.fgColor'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'\n currentMap['name'] = 'fgColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['default'] = '#000000'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute AnalysisProfile.font\n currentMap = {}\n contentMap['font'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'] = currentMap\n loadMaps['ANAP.AnalysisProfile.font'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.font'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'\n currentMap['name'] = 'font'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.graphicsHandler\n currentMap = {}\n contentMap['graphicsHandler'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'] = currentMap\n loadMaps['ANAP.AnalysisProfile.graphicsHandler'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.graphicsHandler'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'\n currentMap['name'] = 'graphicsHandler'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'Tk'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001')\n\n # Attribute AnalysisProfile.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute AnalysisProfile.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute AnalysisProfile.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'] = currentMap\n loadMaps['ANAP.AnalysisProfile.name'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute AnalysisProfile.panView\n currentMap = {}\n contentMap['panView'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'] = currentMap\n loadMaps['ANAP.AnalysisProfile.panView'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.panView'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'\n currentMap['name'] = 'panView'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.sendBugReports\n currentMap = {}\n contentMap['sendBugReports'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'] = currentMap\n loadMaps['ANAP.AnalysisProfile.sendBugReports'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.sendBugReports'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'\n currentMap['name'] = 'sendBugReports'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'maybe'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2010-11-17-16:21:33_00001')\n\n # Attribute AnalysisProfile.transientDialogs\n currentMap = {}\n contentMap['transientDialogs'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'] = currentMap\n loadMaps['ANAP.AnalysisProfile.transientDialogs'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientDialogs'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'\n currentMap['name'] = 'transientDialogs'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.transientWindows\n currentMap = {}\n contentMap['transientWindows'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'] = currentMap\n loadMaps['ANAP.AnalysisProfile.transientWindows'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientWindows'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'\n currentMap['name'] = 'transientWindows'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.twoCharShortcuts\n currentMap = {}\n contentMap['twoCharShortcuts'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'] = currentMap\n loadMaps['ANAP.AnalysisProfile.twoCharShortcuts'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.twoCharShortcuts'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'\n currentMap['name'] = 'twoCharShortcuts'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.useCrosshair\n currentMap = {}\n contentMap['useCrosshair'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'] = currentMap\n loadMaps['ANAP.AnalysisProfile.useCrosshair'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.useCrosshair'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'\n currentMap['name'] = 'useCrosshair'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = True\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.useGlobalShortcuts\n currentMap = {}\n contentMap['useGlobalShortcuts'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'] = currentMap\n loadMaps['ANAP.AnalysisProfile.useGlobalShortcuts'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.useGlobalShortcuts'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'\n currentMap['name'] = 'useGlobalShortcuts'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute AnalysisProfile.userEmail\n currentMap = {}\n contentMap['userEmail'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userEmail'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userEmail'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'\n currentMap['name'] = 'userEmail'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute AnalysisProfile.userName\n currentMap = {}\n contentMap['userName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userName'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'\n currentMap['name'] = 'userName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.userOrganisation\n currentMap = {}\n contentMap['userOrganisation'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'] = currentMap\n loadMaps['ANAP.AnalysisProfile.userOrganisation'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.userOrganisation'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'\n currentMap['name'] = 'userOrganisation'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute AnalysisProfile.webBrowser\n currentMap = {}\n contentMap['webBrowser'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'] = currentMap\n loadMaps['ANAP.AnalysisProfile.webBrowser'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.webBrowser'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'\n currentMap['name'] = 'webBrowser'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role AnalysisProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role AnalysisProfile.colorSchemes\n currentMap = {}\n contentMap['colorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'] = currentMap\n loadMaps['ANAP.AnalysisProfile.colorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.colorSchemes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'\n currentMap['name'] = 'colorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.macros\n currentMap = {}\n contentMap['macros'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'] = currentMap\n loadMaps['ANAP.AnalysisProfile.macros'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.macros'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'\n currentMap['name'] = 'macros'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.marksColor\n currentMap = {}\n contentMap['marksColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'] = currentMap\n loadMaps['ANAP.AnalysisProfile.marksColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.marksColor'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'\n currentMap['name'] = 'marksColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['implSkip'] = True\n currentMap['copyOverride'] = True\n\n # Role AnalysisProfile.refExpProfiles\n currentMap = {}\n contentMap['refExpProfiles'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'] = currentMap\n loadMaps['ANAP.AnalysisProfile.refExpProfiles'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.refExpProfiles'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'\n currentMap['name'] = 'refExpProfiles'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.residueProfiles\n currentMap = {}\n contentMap['residueProfiles'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'] = currentMap\n loadMaps['ANAP.AnalysisProfile.residueProfiles'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.residueProfiles'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'\n currentMap['name'] = 'residueProfiles'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\n\n # Role AnalysisProfile.rulersColor\n currentMap = {}\n contentMap['rulersColor'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'] = currentMap\n loadMaps['ANAP.AnalysisProfile.rulersColor'] = currentMap\n currentMap['tag'] = 'ANAP.AnalysisProfile.rulersColor'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'\n currentMap['name'] = 'rulersColor'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['implSkip'] = True\n currentMap['copyOverride'] = True\n # End of AnalysisProfile\n\n currentMap = abstractTypes.get('AnalysisProfile')\n aList = ['createdBy', 'graphicsHandler', 'guid', 'isModifiable', 'lastUnlockedBy', 'name', 'panView', 'sendBugReports', 'transientDialogs', 'transientWindows', 'twoCharShortcuts', 'useCrosshair', 'useGlobalShortcuts', 'userEmail', 'webBrowser']\n currentMap['headerAttrs'] = aList\n aList = ['bgColor', 'fgColor', 'font', 'userName', 'userOrganisation', 'marksColor', 'rulersColor']\n currentMap['simpleAttrs'] = aList\n aList = ['residueProfiles', 'refExpProfiles', 'macros', 'colorSchemes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['colorSchemes', 'macros', 'refExpProfiles', 'residueProfiles']\n currentMap['children'] = aList\n\n # Class ColorScheme\n currentMap = {}\n abstractTypes['ColorScheme'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'] = currentMap\n loadMaps['ANAP.ColorScheme'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'colorSchemes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ColorScheme.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ColorScheme.colors\n currentMap = {}\n contentMap['colors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'] = currentMap\n loadMaps['ANAP.ColorScheme.colors'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme.colors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'\n currentMap['name'] = 'colors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute ColorScheme.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'] = currentMap\n loadMaps['ANAP.ColorScheme.name'] = currentMap\n currentMap['tag'] = 'ANAP.ColorScheme.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role ColorScheme.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of ColorScheme\n\n currentMap = abstractTypes.get('ColorScheme')\n aList = ['colors', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class Macro\n currentMap = {}\n abstractTypes['Macro'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'] = currentMap\n loadMaps['ANAP.Macro'] = currentMap\n currentMap['tag'] = 'ANAP.Macro'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'macros'\n currentMap['objkey'] = 'serial'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Macro.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Macro.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'] = currentMap\n loadMaps['ANAP.Macro.details'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute Macro.function\n currentMap = {}\n contentMap['function'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'] = currentMap\n loadMaps['ANAP.Macro.function'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.function'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'\n currentMap['name'] = 'function'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute Macro.isInMenu\n currentMap = {}\n contentMap['isInMenu'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'] = currentMap\n loadMaps['ANAP.Macro.isInMenu'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.isInMenu'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'\n currentMap['name'] = 'isInMenu'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute Macro.isInMouseMenu\n currentMap = {}\n contentMap['isInMouseMenu'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'] = currentMap\n loadMaps['ANAP.Macro.isInMouseMenu'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.isInMouseMenu'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'\n currentMap['name'] = 'isInMouseMenu'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = False\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\n\n # Attribute Macro.module\n currentMap = {}\n contentMap['module'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'] = currentMap\n loadMaps['ANAP.Macro.module'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.module'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'\n currentMap['name'] = 'module'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute Macro.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'] = currentMap\n loadMaps['ANAP.Macro.name'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Attribute Macro.ordering\n currentMap = {}\n contentMap['ordering'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'] = currentMap\n loadMaps['ANAP.Macro.ordering'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.ordering'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'\n currentMap['name'] = 'ordering'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['default'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Macro.path\n currentMap = {}\n contentMap['path'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'] = currentMap\n loadMaps['ANAP.Macro.path'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.path'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'\n currentMap['name'] = 'path'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00003')\n\n # Attribute Macro.serial\n currentMap = {}\n contentMap['serial'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'] = currentMap\n loadMaps['ANAP.Macro.serial'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.serial'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'\n currentMap['name'] = 'serial'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Macro.shortcut\n currentMap = {}\n contentMap['shortcut'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'] = currentMap\n loadMaps['ANAP.Macro.shortcut'] = currentMap\n currentMap['tag'] = 'ANAP.Macro.shortcut'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'\n currentMap['name'] = 'shortcut'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role Macro.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of Macro\n\n currentMap = abstractTypes.get('Macro')\n aList = ['function', 'isInMenu', 'isInMouseMenu', 'module', 'ordering', 'serial', 'shortcut']\n currentMap['headerAttrs'] = aList\n aList = ['details', 'name', 'path']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class RefExpProfile\n currentMap = {}\n abstractTypes['RefExpProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'] = currentMap\n loadMaps['ANAP.RefExpProfile'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'refExpProfiles'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute RefExpProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute RefExpProfile.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'] = currentMap\n loadMaps['ANAP.RefExpProfile.name'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Attribute RefExpProfile.peakSymbolColors\n currentMap = {}\n contentMap['peakSymbolColors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'] = currentMap\n loadMaps['ANAP.RefExpProfile.peakSymbolColors'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.peakSymbolColors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'\n currentMap['name'] = 'peakSymbolColors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute RefExpProfile.peakTextColors\n currentMap = {}\n contentMap['peakTextColors'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'] = currentMap\n loadMaps['ANAP.RefExpProfile.peakTextColors'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.peakTextColors'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'\n currentMap['name'] = 'peakTextColors'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\n\n # Attribute RefExpProfile.refExpNames\n currentMap = {}\n contentMap['refExpNames'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'] = currentMap\n loadMaps['ANAP.RefExpProfile.refExpNames'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.refExpNames'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'\n currentMap['name'] = 'refExpNames'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role RefExpProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role RefExpProfile.negColorSchemes\n currentMap = {}\n contentMap['negColorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'] = currentMap\n loadMaps['ANAP.RefExpProfile.negColorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.negColorSchemes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'\n currentMap['name'] = 'negColorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n\n # Role RefExpProfile.posColorSchemes\n currentMap = {}\n contentMap['posColorSchemes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'] = currentMap\n loadMaps['ANAP.RefExpProfile.posColorSchemes'] = currentMap\n currentMap['tag'] = 'ANAP.RefExpProfile.posColorSchemes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'\n currentMap['name'] = 'posColorSchemes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of RefExpProfile\n\n currentMap = abstractTypes.get('RefExpProfile')\n aList = ['name']\n currentMap['headerAttrs'] = aList\n aList = ['peakSymbolColors', 'peakTextColors', 'refExpNames', 'negColorSchemes', 'posColorSchemes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ResidueProfile\n currentMap = {}\n abstractTypes['ResidueProfile'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'] = currentMap\n loadMaps['ANAP.ResidueProfile'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'residueProfiles'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ResidueProfile.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ResidueProfile.ccpCode\n currentMap = {}\n contentMap['ccpCode'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'] = currentMap\n loadMaps['ANAP.ResidueProfile.ccpCode'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.ccpCode'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'\n currentMap['name'] = 'ccpCode'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ResidueProfile.guiName\n currentMap = {}\n contentMap['guiName'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'] = currentMap\n loadMaps['ANAP.ResidueProfile.guiName'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.guiName'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'\n currentMap['name'] = 'guiName'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\n\n # Attribute ResidueProfile.molType\n currentMap = {}\n contentMap['molType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'] = currentMap\n loadMaps['ANAP.ResidueProfile.molType'] = currentMap\n currentMap['tag'] = 'ANAP.ResidueProfile.molType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'\n currentMap['name'] = 'molType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\n\n # Role ResidueProfile.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of ResidueProfile\n\n currentMap = abstractTypes.get('ResidueProfile')\n aList = ['ccpCode', 'guiName', 'molType']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to AnalysisProfile\n currentMap = {}\n exolinks['AnalysisProfile'] = currentMap\n loadMaps['ANAP.exo-AnalysisProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-AnalysisProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\n currentMap['name'] = 'AnalysisProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to ColorScheme\n currentMap = {}\n exolinks['ColorScheme'] = currentMap\n loadMaps['ANAP.exo-ColorScheme'] = currentMap\n currentMap['tag'] = 'ANAP.exo-ColorScheme'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\n currentMap['name'] = 'ColorScheme'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to Macro\n currentMap = {}\n exolinks['Macro'] = currentMap\n loadMaps['ANAP.exo-Macro'] = currentMap\n currentMap['tag'] = 'ANAP.exo-Macro'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\n currentMap['name'] = 'Macro'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\n\n # Out-of-package link to RefExpProfile\n currentMap = {}\n exolinks['RefExpProfile'] = currentMap\n loadMaps['ANAP.exo-RefExpProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-RefExpProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\n currentMap['name'] = 'RefExpProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\n\n # Out-of-package link to ResidueProfile\n currentMap = {}\n exolinks['ResidueProfile'] = currentMap\n loadMaps['ANAP.exo-ResidueProfile'] = currentMap\n currentMap['tag'] = 'ANAP.exo-ResidueProfile'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\n currentMap['name'] = 'ResidueProfile'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))","def demo_one_map():\n radii = [2, 5, 7.1, 0.3, 10]\n demo_1(radii)\n demo_2(radii)","def making_map():\n account = request.form['tweecount']\n number = request.form['num_friends']\n n_map = map(authorization(account, number))\n return n_map","def requires_mapping(self):","def mapper(fun: Callable[[str], Pin], /) -> None:","def scan(self):\n for fn in self.map:\n coords = list(self.map[fn].keys())\n coords.sort()\n for coord in coords:\n yield fn, coord, self.map[fn][coord]","def build_I_map(self):\n raise NotImplementedError","def udcall_map_first(*args):\n return _ida_hexrays.udcall_map_first(*args)","def map(self):\n map_rupture(self)","def getMapping(self):\n self._process()\n return self._mapping","def demo_two_map():\n # example using map\n temps_c = [(\"Berlin\", 29), (\"Cairo\", 36), (\"Buenos Aires\", 19),\n (\"Los Angeles\", 26), (\"Tokyo\", 27), (\"New York\", 28),\n (\"London\", 22), (\"Beijing\", 32)]\n\n # lambda to return tuple with calculated deg. F converted from deg. C\n c2f = lambda city_tmp: (city_tmp[0], (9.0/5.0)*city_tmp[1] + 32)\n\n print list(map(c2f, temps_c))","def map(self):\n return self.map_digis(self.group)","def test_tuple_input(self):\n \n self._tuple1 = 1, 2, 3\n self._tuple2 = 'yes', 'y', 'hey'\n self.assertEqual(False, maps.map_list(self._tuple1))\n self.assertEqual(False, maps.map_list(self._tuple2))","def components_map(self):\r\n raise NotImplementedError","def map(self, func):\n return List(map(func, self))","def get(self):\n maps = Map.all()\n results = [map_object.serialize() for map_object in maps]\n return results, status.HTTP_200_OK","def __call__(self, func, *args, **kwds):\r\n results = self.map(func, *args, **kwds)\r\n if results:\r\n return results[0]","def test_map(self):\n\n test_cases = [\n Case(\n description=\"lists of objects\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, {\"title\": \"baz\"}],\n args=[\"title\"],\n kwargs={},\n expect=[\"foo\", \"bar\", \"baz\"],\n ),\n Case(\n description=\"missing argument\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, {\"title\": \"baz\"}],\n args=[],\n kwargs={},\n expect=FilterArgumentError,\n ),\n Case(\n description=\"too many arguments\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, {\"title\": \"baz\"}],\n args=[\"title\", \"\"],\n kwargs={},\n expect=FilterArgumentError,\n ),\n Case(\n description=\"missing property\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, {\"heading\": \"baz\"}],\n args=[\"title\"],\n kwargs={},\n expect=[\"foo\", \"bar\", None],\n ),\n Case(\n description=\"value not an array\",\n val=123,\n args=[\"title\"],\n kwargs={},\n expect=FilterValueError,\n ),\n Case(\n description=\"array contains non object\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, 5, []],\n args=[\"title\"],\n kwargs={},\n expect=FilterValueError,\n ),\n Case(\n description=\"undefined left value\",\n val=self.env.undefined(\"test\"),\n args=[\"title\"],\n kwargs={},\n expect=[],\n ),\n Case(\n description=\"undefined argument\",\n val=[{\"title\": \"foo\"}, {\"title\": \"bar\"}, {\"title\": \"baz\"}],\n args=[self.env.undefined(\"test\")],\n kwargs={},\n expect=[None, None, None],\n ),\n ]\n\n self._test(Map, test_cases)","def __call__(self):\n return self._main._items()","def map(self, func):\n return _(map(func, self._))","def test_map_basics(self):\n self.assertDigitizerMapBasics(self.map, self.dgroup)","def map(self) -> global___Statement.Declaration:","def request_map():\n\n rospy.loginfo(\"Requesting the map\")\n rospy.wait_for_service('dynamic_map')\n getMap = rospy.ServiceProxy('dynamic_map', GetMap)\n g = getMap().map\n\n return g","def __call__(self, circuit=None):\n if isinstance(self.map, dict):\n pass\n elif isinstance(self.map, list):\n self.map = dict(zip(list(\"q\" + str(i) for i in range(len(self.map))), self.map))\n else:\n raise_error(TypeError, \"Use dict or list to define mapping.\")\n if circuit is not None:\n assert_placement(circuit, self.map)\n else:\n assert_mapping_consistency(self.map)\n return self.map","def result_field_map():\n return {\n \"[run number]\": \"run_number\",\n \"map-file\": \"map_file\",\n \"People\": \"people\",\n \"person_path_weight\": \"person_path_weight\",\n \"Slow\": \"slow\",\n \"Medium\": \"medium\",\n \"Fast\": \"fast\",\n \"display-path-cost?\": \"display_path_cost_p\",\n \"add-person-spacing?\": \"add_person_spacing_p\",\n \"people-wait?\": \"people_wait_p\",\n \"equal-diagonal-weight?\": \"equal_diagonal_weight_p\",\n \"Slow-Speed\": \"slow_speed\",\n \"Medium-Speed\": \"medium_speed\",\n \"Fast-Speed\": \"fast_speed\",\n \"set-fire?\": \"set_fire_p\",\n \"Fire_Speed\": \"fire_speed\" ,\n \"mean-escape-time\": \"mean_escape_time\",\n }","def get(self) -> tuple:","def udcall_map_new(*args):\n return _ida_hexrays.udcall_map_new(*args)","def _empty_mapping(self):\r\n return self.type2test()","def testStepBuildStatsMap(self):\n self._StringToMapHelper(data_types.StepBuildStatsMap, data_types.BuildStats)","def fetch_map(self, page, part):\n\n source = self.mapUrl.replace('PAGE', str(page)).replace('PART', str(part))\n html = http_get(source).replace(\"\\n\", \"\")\n map_string = html.split('<map name=\"map1\">')[1].split('</map>')[0]\n p = re.compile('<area COORDS=\"(?P<x1>\\\\d+),(?P<y1>\\\\d+),(?P<x2>\\\\d+),(?P<y2>\\\\d+),?\" href=\"popupTelevideo.jsp\\?p=(?P<page>\\\\d+)&s=(?P<part>\\\\d+)&r=Nazionale\">')\n map = [(int(a[0]) * self.RESIZE_FACTOR, int(a[1]) * self.RESIZE_FACTOR, int(a[2]) * self.RESIZE_FACTOR, int(a[3]) * self.RESIZE_FACTOR, int(a[4]), int(a[5]) + 1) for a in p.findall(map_string)]\n return map","def mapping(self):\n return self.request('_mapping', pylastica.request.Request.GET).data","def _doMap(self, func, iterable):\n name = \"Mapper\"\n sys.stderr.write(\"Master[%s phase]: starting\\n\" % name)\n pipes = [mp.Pipe() for _ in range(self.num_workers)]\n proc = [mp.Process(target=spawn_mapper(func), name=name, args=(q,)) for q in pipes]\n for p in proc:\n p.daemon = True\n p.start()\n for output_p, input_p in pipes:\n input_p.close() # we don't need to read from the pipes\n qi = 0\n for item in iterable:\n pipes[qi][0].send(item)\n qi = (qi+1) % self.num_workers\n for q,_ in pipes:\n q.send(None) # add termination tokens\n q.close()\n for p in proc:\n p.join()\n sys.stderr.write(\"Master[%s phase]: ended..\\n\" % name)","def MakeFieldmaps(self):\n if self.verbose:\n print 'Compute fieldmaps.'\n for entry in self.info:\n if self.info[entry]['type'] == 'fmap':\n if self.info[entry]['imgfile'] == None:\n# Fieldmap data not found.\n return\n# Make a magnitude image for use in checking registration.\n cmd = 'convert_file -f0 -m0 %s %s nii' % \\\n (entry, self.info[entry]['magfile'])\n self.CheckExec(cmd, [self.info[entry]['magfile'] + '.nii'])\n\n# Make fieldmap. Use separate loop in case make_fmap aborts.\n for entry in self.info:\n if self.info[entry]['type'] == 'fmap':\n fmapname = self.info[entry]['imgfile']\n if not os.path.exists('%s.nii' % fmapname) or self.redo:\n# Couldn't find or existing fmap, compute a new one.\n if self.verbose:\n extra_args = '-v'\n else:\n extra_args = ''\n if self.info[entry]['correct_fmap_phase'] == 'force':\n extra_args += ' --force-slicecorr'\n elif self.info[entry]['correct_fmap_phase'] == 'omit':\n extra_args += ' --omit-slicecorr'\n cmd = 'make_fmap %s %s %s' % (extra_args, entry, fmapname)\n# error = self.ExecCmd(cmd, halt_on_error=False)\n if self.no_fmapcorr:\n halt_on_error = False\n else:\n halt_on_error = True\n error = self.CheckExec(cmd, ['%s.nii' % fmapname], \\\n halt_on_error=halt_on_error)\n if error:\n self.info[entry]['valid'] = False\n del self.fmaps[entry]","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CHEL').get('abstractTypes')\n exolinks = globalMap.get('CHEL').get('exolinks')\n\n # DataType HalfLifeType\n currentMap = {}\n abstractTypes['HalfLifeType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'] = currentMap\n loadMaps['CHEL.HalfLifeType'] = currentMap\n currentMap['tag'] = 'CHEL.HalfLifeType'\n currentMap['type'] = 'simple'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'\n currentMap['toStr'] = 'text'\n currentMap['cnvrt'] = 'text'\n\n # Class ChemElement\n currentMap = {}\n abstractTypes['ChemElement'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'] = currentMap\n loadMaps['CHEL.ChemElement'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemElements'\n currentMap['objkey'] = 'symbol'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemElement.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemElement.atomNumber\n currentMap = {}\n contentMap['atomNumber'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'] = currentMap\n loadMaps['CHEL.ChemElement.atomNumber'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.atomNumber'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'\n currentMap['name'] = 'atomNumber'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['proc'] = 'direct'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute ChemElement.atomicRadius\n currentMap = {}\n contentMap['atomicRadius'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'] = currentMap\n loadMaps['CHEL.ChemElement.atomicRadius'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.atomicRadius'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'\n currentMap['name'] = 'atomicRadius'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.covalentRadius\n currentMap = {}\n contentMap['covalentRadius'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'] = currentMap\n loadMaps['CHEL.ChemElement.covalentRadius'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.covalentRadius'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'\n currentMap['name'] = 'covalentRadius'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.mass\n currentMap = {}\n contentMap['mass'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'] = currentMap\n loadMaps['CHEL.ChemElement.mass'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.mass'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'\n currentMap['name'] = 'mass'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute ChemElement.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'] = currentMap\n loadMaps['CHEL.ChemElement.name'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\n\n # Attribute ChemElement.symbol\n currentMap = {}\n contentMap['symbol'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'] = currentMap\n loadMaps['CHEL.ChemElement.symbol'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.symbol'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'\n currentMap['name'] = 'symbol'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\n\n # Role ChemElement.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemElement.isotopes\n currentMap = {}\n contentMap['isotopes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'] = currentMap\n loadMaps['CHEL.ChemElement.isotopes'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElement.isotopes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'\n currentMap['name'] = 'isotopes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\n # End of ChemElement\n\n currentMap = abstractTypes.get('ChemElement')\n aList = ['atomNumber', 'atomicRadius', 'covalentRadius', 'mass', 'name', 'symbol']\n currentMap['headerAttrs'] = aList\n aList = ['isotopes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['isotopes']\n currentMap['children'] = aList\n\n # Class ChemElementStore\n currentMap = {}\n abstractTypes['ChemElementStore'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'] = currentMap\n loadMaps['CHEL.ChemElementStore'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'chemElementStores'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ChemElementStore.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ChemElementStore.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute ChemElementStore.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute ChemElementStore.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'] = currentMap\n loadMaps['CHEL.ChemElementStore.name'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role ChemElementStore.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ChemElementStore.chemElements\n currentMap = {}\n contentMap['chemElements'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'] = currentMap\n loadMaps['CHEL.ChemElementStore.chemElements'] = currentMap\n currentMap['tag'] = 'CHEL.ChemElementStore.chemElements'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'\n currentMap['name'] = 'chemElements'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\n # End of ChemElementStore\n\n currentMap = abstractTypes.get('ChemElementStore')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\n currentMap['headerAttrs'] = aList\n aList = ['name']\n currentMap['simpleAttrs'] = aList\n aList = ['chemElements', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['chemElements']\n currentMap['children'] = aList\n\n # Class Isotope\n currentMap = {}\n abstractTypes['Isotope'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'] = currentMap\n loadMaps['CHEL.Isotope'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'isotopes'\n currentMap['objkey'] = 'massNumber'\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Isotope.abundance\n currentMap = {}\n contentMap['abundance'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'] = currentMap\n loadMaps['CHEL.Isotope.abundance'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.abundance'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'\n currentMap['name'] = 'abundance'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00058')\n\n # Attribute Isotope.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Isotope.gyroMagneticRatio\n currentMap = {}\n contentMap['gyroMagneticRatio'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'] = currentMap\n loadMaps['CHEL.Isotope.gyroMagneticRatio'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.gyroMagneticRatio'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'\n currentMap['name'] = 'gyroMagneticRatio'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.halfLife\n currentMap = {}\n contentMap['halfLife'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'] = currentMap\n loadMaps['CHEL.Isotope.halfLife'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLife'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'\n currentMap['name'] = 'halfLife'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\n\n # Attribute Isotope.halfLifeError\n currentMap = {}\n contentMap['halfLifeError'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'] = currentMap\n loadMaps['CHEL.Isotope.halfLifeError'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLifeError'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'\n currentMap['name'] = 'halfLifeError'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\n\n # Attribute Isotope.halfLifeType\n currentMap = {}\n contentMap['halfLifeType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'] = currentMap\n loadMaps['CHEL.Isotope.halfLifeType'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.halfLifeType'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'\n currentMap['name'] = 'halfLifeType'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['default'] = 'unknown'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002')\n\n # Attribute Isotope.magneticMoment\n currentMap = {}\n contentMap['magneticMoment'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'] = currentMap\n loadMaps['CHEL.Isotope.magneticMoment'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.magneticMoment'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'\n currentMap['name'] = 'magneticMoment'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.mass\n currentMap = {}\n contentMap['mass'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'] = currentMap\n loadMaps['CHEL.Isotope.mass'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.mass'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'\n currentMap['name'] = 'mass'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.massNumber\n currentMap = {}\n contentMap['massNumber'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'] = currentMap\n loadMaps['CHEL.Isotope.massNumber'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.massNumber'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'\n currentMap['name'] = 'massNumber'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['proc'] = 'direct'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\n\n # Attribute Isotope.quadrupoleMoment\n currentMap = {}\n contentMap['quadrupoleMoment'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'] = currentMap\n loadMaps['CHEL.Isotope.quadrupoleMoment'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.quadrupoleMoment'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'\n currentMap['name'] = 'quadrupoleMoment'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.receptivity\n currentMap = {}\n contentMap['receptivity'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'] = currentMap\n loadMaps['CHEL.Isotope.receptivity'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.receptivity'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'\n currentMap['name'] = 'receptivity'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\n\n # Attribute Isotope.spin\n currentMap = {}\n contentMap['spin'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'] = currentMap\n loadMaps['CHEL.Isotope.spin'] = currentMap\n currentMap['tag'] = 'CHEL.Isotope.spin'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'\n currentMap['name'] = 'spin'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\n\n # Role Isotope.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of Isotope\n\n currentMap = abstractTypes.get('Isotope')\n aList = ['abundance', 'gyroMagneticRatio', 'halfLife', 'halfLifeError', 'halfLifeType', 'magneticMoment', 'mass', 'massNumber', 'quadrupoleMoment', 'receptivity', 'spin']\n currentMap['headerAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to ChemElement\n currentMap = {}\n exolinks['ChemElement'] = currentMap\n loadMaps['CHEL.exo-ChemElement'] = currentMap\n currentMap['tag'] = 'CHEL.exo-ChemElement'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\n currentMap['name'] = 'ChemElement'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\n\n # Out-of-package link to ChemElementStore\n currentMap = {}\n exolinks['ChemElementStore'] = currentMap\n loadMaps['CHEL.exo-ChemElementStore'] = currentMap\n currentMap['tag'] = 'CHEL.exo-ChemElementStore'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\n currentMap['name'] = 'ChemElementStore'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to Isotope\n currentMap = {}\n exolinks['Isotope'] = currentMap\n loadMaps['CHEL.exo-Isotope'] = currentMap\n currentMap['tag'] = 'CHEL.exo-Isotope'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\n currentMap['name'] = 'Isotope'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))","def get_all_locations(self):","def print_current_mappings(self):\n for mapped_name in self.__mapped_names:\n func = getattr(self, mapped_name)\n name = f'{func.__module__}.{func.__name__}'\n print(f'* {mapped_name} -- {name}')","def map(self, app, node):","def map(self) -> Map:\n return self._map","def _mapping(self):\n return [('message.received', self.on_new_message), \\\n ('message.read.prevent', self.can_not_read)]","def _SetFmapInfo(self):\n for epi in self.pfiles + self.epirt_paths:\n self.info[epi]['fmapname'] = None\n self.info[epi]['fmap_entry'] = None\n for entry in self.entry_map['fmap']:\n fmap_name = self.info[entry]['imgfile'] + self.info[entry]['suffix']\n if self.info[entry]['plane'] == self.info[epi]['plane']:\n# Use the fieldmap acquired at the same plane.\n self.info[epi]['fmapname'] = fmap_name\n self.info[epi]['fmap_entry'] = entry\n break\n else:\n# for fmap in self.fmaps.keys():\n for entry in self.entry_map['fmap']:\n# No fmap at same orientation, look for fmaps in other planes.\n# There won't be more than one, so it isn't much of a choice.\n fmap_name = self.info[entry]['imgfile'] + \\\n self.info[entry]['suffix']\n if self.info[entry]['plane'] == 'sagittal':\n self.info[epi]['fmapname'] = fmap_name\n self.info[epi]['fmap_entry'] = entry\n break\n elif self.info[entry]['plane'] == 'axial':\n self.info[epi]['fmapname'] = fmap_name\n self.info[epi]['fmap_entry'] = entry\n break\n elif self.info[entry]['plane'] == 'coronal':\n self.info[epi]['fmapname'] = fmap_name\n self.info[epi]['fmap_entry'] = entry\n break\n elif self.info[entry]['plane'] == 'oblique':\n self.info[epi]['fmapname'] = fmap_name\n self.info[epi]['fmap_entry'] = entry\n self.info[epi]['plane'] = 'oblique'\n break","def map_profile_info(profile):\n result = map(\n lambda p: {\n 'callcount': p.callcount,\n 'time': p.totaltime,\n 'name': p.code if isinstance(p.code, str) else p.code.co_name,\n 'file': None if isinstance(p.code, str) else p.code.co_filename},\n profile.getstats())\n return result","def tuple_map(x):\n return x * 2","def get_mapping(proj,exp):\n response = do_method(\"experiment.info\",\n {\"proj\":proj,\"exp\":exp,\"aspect\":\"mapping\"})\n check_response(response)\n return response['value']","def map_generate_tuple(*args):\n key, func, arg = args[0][0], args[0][1], args[0][2]\n return (key, func(*arg))","def info() -> Dict[str, Any]:","def get_forward_mapping(self):","def get_MAP(prior,likelihood):\n pr = np.array(prior)\n ll = np.array(likelihood)\n\n ps = np.dot(pr * ll)\n ps /= np.sum(ps)\n\n map_idx = np.argmax(ps)\n return (map_idx,ps)","def get_info(cls, icao_id: str) -> Tuple[str, str]:\n if len(cls.mapping) == 0:\n cls._generate_mapping()\n return cls.mapping.get(icao_id.lower(), ('Unknown', 'Unknown'))","def _get_mapVersion(self):\n return self.__mapVersion","def fetchGeoData():\n if request.method ==\"POST\":\n result = {}\n if request.get_json():\n post_requests = request.get_json()\n print(post_requests)\n result = db.getmapdata(post_requests['attr']) \n return result","def parse_mapping_page(self, id, body):\n info = {}\n info['original'] = self.__re_search(body, *self.regx['original'])\n info['save'] = self.__re_search(body, *self.regx['save'])\n info['price'] = self.__re_search(body, *self.regx['price'])\n info['rebate'] = self.__re_search(body, *self.regx['rebate'])\n return info","def map_value(self) -> global___Expression.MapValue:","def map(iteratee, *seqs):\n return _map(fnc.iteratee(iteratee), *seqs)","def testBuilderStepMap(self):\n self._StringToMapHelper(data_types.BuilderStepMap,\n data_types.StepBuildStatsMap)","def get_map(self):\n\n self.mp = defaultdict(lambda : ord('x'))\n y, x = 0, 0\n while True:\n cond, output = self.ic()\n\n if cond: break\n # New row of the print out\n if output == 10:\n y += 1\n x = 0\n # Assign the value to the map\n else:\n self.mp[y,x] = output\n x += 1\n \n return self.mp","def map():\n return render_template('map.html')","def test_name_to_func_map(self):\n test_file = 'tests/commentsForProtobuf'\n options = Namespace()\n options.already = set()\n options.ex_re = None\n options.map_holder = MapHolder()\n options.verbose = False\n\n lines, sloc = count_lines_protobuf(test_file, options, 'py')\n self.assertEqual(lines, 71)\n self.assertEqual(sloc, 46)","def udcall_map_find(*args):\n return _ida_hexrays.udcall_map_find(*args)","def _getMappingInfo(\n\textractionCtx: ExtractionContext\n) -> List[_MappingInfo]:\n\tdyldCtx = extractionCtx.dyldCtx\n\tlogger = extractionCtx.logger\n\n\tmappingInfo = []\n\n\tif dyldCtx.header.slideInfoOffsetUnused:\n\t\t# Assume the legacy case with no sub caches, and only one slide info\n\t\tif dyldCtx.hasSubCaches():\n\t\t\tlogger.error(\"Legacy slide info with sub caches.\")\n\t\t\tpass\n\n\t\t# the version is encoded as the first uint32 field\n\t\tslideInfoOff = dyldCtx.header.slideInfoOffsetUnused\n\t\tslideInfoVer = dyldCtx.readFormat(\"<I\", slideInfoOff)[0]\n\n\t\tif slideInfoVer not in _SlideInfoMap:\n\t\t\tlogger.error(\"Unknown slide info version: \" + slideInfoVer)\n\t\t\treturn None\n\n\t\t# Assume that only the second mapping has slide info\n\t\tmapping = dyldCtx.mappings[1][0]\n\t\tslideInfo = _SlideInfoMap[slideInfoVer](dyldCtx.file, slideInfoOff)\n\t\tmappingInfo.append(_MappingInfo(mapping, slideInfo, dyldCtx))\n\t\tpass\n\n\telse:\n\t\tfor mapping, context in dyldCtx.mappings:\n\t\t\tif not context.headerContainsField(\"mappingWithSlideOffset\"):\n\t\t\t\tlogger.error(\"Unable to pair mapping with slide info.\")\n\t\t\t\tcontinue\n\n\t\t\t# Get the expanded mapping info\n\t\t\tmapI = context.mappings.index((mapping, context))\n\t\t\tmapOff = (\n\t\t\t\tcontext.header.mappingWithSlideOffset\n\t\t\t\t+ mapI * dyld_cache_mapping_and_slide_info.SIZE\n\t\t\t)\n\n\t\t\tmapping = dyld_cache_mapping_and_slide_info(context.file, mapOff)\n\t\t\tif mapping.slideInfoFileOffset:\n\t\t\t\tslideInfoVer = context.readFormat(\"<I\", mapping.slideInfoFileOffset)[0]\n\n\t\t\t\tif slideInfoVer not in _SlideInfoMap:\n\t\t\t\t\tlogger.error(\"Unknown slide info version: \" + slideInfoVer)\n\t\t\t\t\tcontinue\n\n\t\t\t\tslideInfo = _SlideInfoMap[slideInfoVer](\n\t\t\t\t\tcontext.file,\n\t\t\t\t\tmapping.slideInfoFileOffset\n\t\t\t\t)\n\t\t\t\tmappingInfo.append(_MappingInfo(mapping, slideInfo, context))\n\t\t\t\tpass\n\t\t\tpass\n\t\tpass\n\n\treturn mappingInfo","def Maps(num_maps, num_cities):\n return tuple(Cities(num_cities, seed=(m, num_cities))\n for m in range(num_maps))","def map():\n\n return render_template(\"map.html\")","def makeMapping(globalMap):\n \n from memops.xml.Implementation import bool2str, str2bool\n\n # Set up top level dictionaries\n loadMaps = globalMap.get('loadMaps')\n mapsByGuid = globalMap.get('mapsByGuid')\n\n abstractTypes = globalMap.get('CLAS').get('abstractTypes')\n exolinks = globalMap.get('CLAS').get('exolinks')\n\n # Class AbstractCategory\n currentMap = {}\n abstractTypes['AbstractCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'] = currentMap\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'\n currentMap['eType'] = 'cplx'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.AbstractCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute AbstractCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute AbstractCategory.details\n currentMap = {}\n contentMap['details'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'] = currentMap\n loadMaps['CLAS.AbstractCategory.details'] = currentMap\n currentMap['tag'] = 'CLAS.AbstractCategory.details'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'\n currentMap['name'] = 'details'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Attribute AbstractCategory.name\n currentMap = {}\n contentMap['name'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'] = currentMap\n loadMaps['CLAS.AbstractCategory.name'] = currentMap\n currentMap['tag'] = 'CLAS.AbstractCategory.name'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'\n currentMap['name'] = 'name'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role AbstractCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of AbstractCategory\n\n currentMap = abstractTypes.get('AbstractCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class Classification\n currentMap = {}\n abstractTypes['Classification'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'] = currentMap\n loadMaps['CLAS.Classification'] = currentMap\n currentMap['tag'] = 'CLAS.Classification'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'classifications'\n currentMap['isTop'] = True\n currentMap['objkey'] = 'namingSystem'\n currentMap['class'] = ccp.api.lims.Classification.Classification\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute Classification.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute Classification.createdBy\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.guid\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\n\n # Attribute Classification.isModifiable\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.lastUnlockedBy\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\n\n # Attribute Classification.namingSystem\n currentMap = {}\n contentMap['namingSystem'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'] = currentMap\n loadMaps['CLAS.Classification.namingSystem'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.namingSystem'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'\n currentMap['name'] = 'namingSystem'\n currentMap['hicard'] = 1\n currentMap['locard'] = 1\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\n\n # Role Classification.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role Classification.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'] = currentMap\n loadMaps['CLAS.Classification.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.experimentTypes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.hazardPhrases\n currentMap = {}\n contentMap['hazardPhrases'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'] = currentMap\n loadMaps['CLAS.Classification.hazardPhrases'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.hazardPhrases'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'\n currentMap['name'] = 'hazardPhrases'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.holderCategorys\n currentMap = {}\n contentMap['holderCategorys'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'] = currentMap\n loadMaps['CLAS.Classification.holderCategorys'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.holderCategorys'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'\n currentMap['name'] = 'holderCategorys'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.instrumentTypes\n currentMap = {}\n contentMap['instrumentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'] = currentMap\n loadMaps['CLAS.Classification.instrumentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.instrumentTypes'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'\n currentMap['name'] = 'instrumentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.sampleCategories\n currentMap = {}\n contentMap['sampleCategories'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'] = currentMap\n loadMaps['CLAS.Classification.sampleCategories'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.sampleCategories'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'\n currentMap['name'] = 'sampleCategories'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.sampleComponentCategory\n currentMap = {}\n contentMap['sampleComponentCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'] = currentMap\n loadMaps['CLAS.Classification.sampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.sampleComponentCategory'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'\n currentMap['name'] = 'sampleComponentCategory'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.targetScoreboards\n currentMap = {}\n contentMap['targetScoreboards'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'] = currentMap\n loadMaps['CLAS.Classification.targetScoreboards'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.targetScoreboards'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'\n currentMap['name'] = 'targetScoreboards'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n\n # Role Classification.targetStatus\n currentMap = {}\n contentMap['targetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'] = currentMap\n loadMaps['CLAS.Classification.targetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.Classification.targetStatus'\n currentMap['type'] = 'child'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'\n currentMap['name'] = 'targetStatus'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['implSkip'] = True\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\n # End of Classification\n\n currentMap = abstractTypes.get('Classification')\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\n currentMap['headerAttrs'] = aList\n aList = ['namingSystem']\n currentMap['simpleAttrs'] = aList\n aList = ['targetStatus', 'targetScoreboards', 'sampleComponentCategory', 'sampleCategories', 'instrumentTypes', 'holderCategorys', 'hazardPhrases', 'experimentTypes', 'access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n aList = ['experimentTypes', 'hazardPhrases', 'holderCategorys', 'instrumentTypes', 'sampleCategories', 'sampleComponentCategory', 'targetScoreboards', 'targetStatus']\n currentMap['children'] = aList\n\n # Class SampleComponentCategory\n currentMap = {}\n abstractTypes['SampleComponentCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'] = currentMap\n loadMaps['CLAS.SampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.SampleComponentCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'sampleComponentCategory'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute SampleComponentCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute SampleComponentCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute SampleComponentCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role SampleComponentCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of SampleComponentCategory\n\n currentMap = abstractTypes.get('SampleComponentCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class ExperimentType\n currentMap = {}\n abstractTypes['ExperimentType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'] = currentMap\n loadMaps['CLAS.ExperimentType'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'experimentTypes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute ExperimentType.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute ExperimentType.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute ExperimentType.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role ExperimentType.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role ExperimentType.instrumentTypes\n currentMap = {}\n contentMap['instrumentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'] = currentMap\n loadMaps['CLAS.ExperimentType.instrumentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType.instrumentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'\n currentMap['name'] = 'instrumentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n\n # Role ExperimentType.sampleCategories\n currentMap = {}\n contentMap['sampleCategories'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'] = currentMap\n loadMaps['CLAS.ExperimentType.sampleCategories'] = currentMap\n currentMap['tag'] = 'CLAS.ExperimentType.sampleCategories'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'\n currentMap['name'] = 'sampleCategories'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of ExperimentType\n\n currentMap = abstractTypes.get('ExperimentType')\n aList = ['details', 'name', 'instrumentTypes', 'sampleCategories']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class TargetScoreboard\n currentMap = {}\n abstractTypes['TargetScoreboard'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'] = currentMap\n loadMaps['CLAS.TargetScoreboard'] = currentMap\n currentMap['tag'] = 'CLAS.TargetScoreboard'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'targetScoreboards'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute TargetScoreboard.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute TargetScoreboard.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute TargetScoreboard.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role TargetScoreboard.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role TargetScoreboard.targetStatus\n currentMap = {}\n contentMap['targetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'] = currentMap\n loadMaps['CLAS.TargetScoreboard.targetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.TargetScoreboard.targetStatus'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'\n currentMap['name'] = 'targetStatus'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of TargetScoreboard\n\n currentMap = abstractTypes.get('TargetScoreboard')\n aList = ['details', 'name', 'targetStatus']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class HolderCategory\n currentMap = {}\n abstractTypes['HolderCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'] = currentMap\n loadMaps['CLAS.HolderCategory'] = currentMap\n currentMap['tag'] = 'CLAS.HolderCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'holderCategorys'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute HolderCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute HolderCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute HolderCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role HolderCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of HolderCategory\n\n currentMap = abstractTypes.get('HolderCategory')\n aList = ['details', 'name']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class HazardPhrase\n currentMap = {}\n abstractTypes['HazardPhrase'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'] = currentMap\n loadMaps['CLAS.HazardPhrase'] = currentMap\n currentMap['tag'] = 'CLAS.HazardPhrase'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'hazardPhrases'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute HazardPhrase.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute HazardPhrase.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute HazardPhrase.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Attribute HazardPhrase.phrase\n currentMap = {}\n contentMap['phrase'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'] = currentMap\n loadMaps['CLAS.HazardPhrase.phrase'] = currentMap\n currentMap['tag'] = 'CLAS.HazardPhrase.phrase'\n currentMap['type'] = 'attr'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'\n currentMap['name'] = 'phrase'\n currentMap['hicard'] = 1\n currentMap['locard'] = 0\n currentMap['eType'] = 'cplx'\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\n\n # Role HazardPhrase.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n # End of HazardPhrase\n\n currentMap = abstractTypes.get('HazardPhrase')\n aList = ['details', 'name', 'phrase']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class InstrumentType\n currentMap = {}\n abstractTypes['InstrumentType'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'] = currentMap\n loadMaps['CLAS.InstrumentType'] = currentMap\n currentMap['tag'] = 'CLAS.InstrumentType'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'instrumentTypes'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute InstrumentType.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute InstrumentType.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute InstrumentType.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role InstrumentType.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role InstrumentType.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'] = currentMap\n loadMaps['CLAS.InstrumentType.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.InstrumentType.experimentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of InstrumentType\n\n currentMap = abstractTypes.get('InstrumentType')\n aList = ['details', 'name', 'experimentTypes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class SampleCategory\n currentMap = {}\n abstractTypes['SampleCategory'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'] = currentMap\n loadMaps['CLAS.SampleCategory'] = currentMap\n currentMap['tag'] = 'CLAS.SampleCategory'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'sampleCategories'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute SampleCategory.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute SampleCategory.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute SampleCategory.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role SampleCategory.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role SampleCategory.experimentTypes\n currentMap = {}\n contentMap['experimentTypes'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'] = currentMap\n loadMaps['CLAS.SampleCategory.experimentTypes'] = currentMap\n currentMap['tag'] = 'CLAS.SampleCategory.experimentTypes'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'\n currentMap['name'] = 'experimentTypes'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of SampleCategory\n\n currentMap = abstractTypes.get('SampleCategory')\n aList = ['details', 'name', 'experimentTypes']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Class TargetStatus\n currentMap = {}\n abstractTypes['TargetStatus'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'] = currentMap\n loadMaps['CLAS.TargetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.TargetStatus'\n currentMap['type'] = 'class'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\n currentMap['eType'] = 'cplx'\n currentMap['fromParent'] = 'targetStatus'\n currentMap['objkey'] = 'name'\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\n contentMap = {}\n currentMap['content'] = contentMap\n\n # Attribute TargetStatus.applicationData\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\n\n # Attribute TargetStatus.details\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\n\n # Attribute TargetStatus.name\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\n\n # Role TargetStatus.access\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\n\n # Role TargetStatus.targetScoreboards\n currentMap = {}\n contentMap['targetScoreboards'] = currentMap\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'] = currentMap\n loadMaps['CLAS.TargetStatus.targetScoreboards'] = currentMap\n currentMap['tag'] = 'CLAS.TargetStatus.targetScoreboards'\n currentMap['type'] = 'link'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'\n currentMap['name'] = 'targetScoreboards'\n currentMap['hicard'] = -1\n currentMap['locard'] = 0\n currentMap['copyOverride'] = True\n # End of TargetStatus\n\n currentMap = abstractTypes.get('TargetStatus')\n aList = ['details', 'name', 'targetScoreboards']\n currentMap['simpleAttrs'] = aList\n aList = ['access', 'applicationData']\n currentMap['cplxAttrs'] = aList\n\n # Out-of-package link to Classification\n currentMap = {}\n exolinks['Classification'] = currentMap\n loadMaps['CLAS.exo-Classification'] = currentMap\n currentMap['tag'] = 'CLAS.exo-Classification'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\n currentMap['name'] = 'Classification'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.Classification\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n\n # Out-of-package link to SampleComponentCategory\n currentMap = {}\n exolinks['SampleComponentCategory'] = currentMap\n loadMaps['CLAS.exo-SampleComponentCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-SampleComponentCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\n currentMap['name'] = 'SampleComponentCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to ExperimentType\n currentMap = {}\n exolinks['ExperimentType'] = currentMap\n loadMaps['CLAS.exo-ExperimentType'] = currentMap\n currentMap['tag'] = 'CLAS.exo-ExperimentType'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\n currentMap['name'] = 'ExperimentType'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to TargetScoreboard\n currentMap = {}\n exolinks['TargetScoreboard'] = currentMap\n loadMaps['CLAS.exo-TargetScoreboard'] = currentMap\n currentMap['tag'] = 'CLAS.exo-TargetScoreboard'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\n currentMap['name'] = 'TargetScoreboard'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to HolderCategory\n currentMap = {}\n exolinks['HolderCategory'] = currentMap\n loadMaps['CLAS.exo-HolderCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-HolderCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\n currentMap['name'] = 'HolderCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to HazardPhrase\n currentMap = {}\n exolinks['HazardPhrase'] = currentMap\n loadMaps['CLAS.exo-HazardPhrase'] = currentMap\n currentMap['tag'] = 'CLAS.exo-HazardPhrase'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\n currentMap['name'] = 'HazardPhrase'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to InstrumentType\n currentMap = {}\n exolinks['InstrumentType'] = currentMap\n loadMaps['CLAS.exo-InstrumentType'] = currentMap\n currentMap['tag'] = 'CLAS.exo-InstrumentType'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\n currentMap['name'] = 'InstrumentType'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to SampleCategory\n currentMap = {}\n exolinks['SampleCategory'] = currentMap\n loadMaps['CLAS.exo-SampleCategory'] = currentMap\n currentMap['tag'] = 'CLAS.exo-SampleCategory'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\n currentMap['name'] = 'SampleCategory'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\n\n # Out-of-package link to TargetStatus\n currentMap = {}\n exolinks['TargetStatus'] = currentMap\n loadMaps['CLAS.exo-TargetStatus'] = currentMap\n currentMap['tag'] = 'CLAS.exo-TargetStatus'\n currentMap['type'] = 'exo'\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\n currentMap['name'] = 'TargetStatus'\n currentMap['eType'] = 'cplx'\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\n aList = list()\n currentMap['keyMaps'] = aList\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))","def get_map(self):\n return self.parent.controller.get_map()","def get_map_values(self, lons, lats, ibin=None):\n raise NotImplementedError(\"MapBase.get_map_values()\")","def melInfo(*args, **kwargs)->List[AnyStr]:\n pass","def manage_getPermissionMapping(self):\n wrapper = getattr(self, '_permissionMapper', None)\n if wrapper is None:\n wrapper = PM()\n\n perms = {}\n for p in self.possible_permissions():\n perms[getPermissionIdentifier(p)] = p\n\n r = []\n a = r.append\n for ac_perms in self.ac_inherited_permissions(1):\n p = perms.get(getPermissionMapping(ac_perms[0], wrapper), '')\n a({'permission_name': ac_perms[0], 'class_permission': p})\n return r","def map2(f, A, B):\n return tuple(map(lambda ra, rb: tuple(map(f, ra, rb)),\n A, B))","def map_callback(self,msg):\n self.map = np.array(msg.data).reshape((msg.info.height, msg.info.width))\n self.map_info = msg.info","def _mapping(self):\n return [('auth.check', self.notify)]","def view(self) -> 'typing.Mapping[int, Dataclass]':"],"string":"[\n \"def map():\",\n \"def map(self):\\r\\n pass\",\n \"def _do_mapping(self):\\n pass\",\n \"def get_data(self) -> Tuple[PoliciesMap, ZonesMap, LinksMap]:\\n return self.policies_map, self.zones_map, self.links_map\",\n \"def _map_fn(self):\\n raise NotImplementedError\",\n \"def map( self ) :\\n\\n self.readMap( )\\n\\n return( self.__map )\",\n \"def applyMapping(self):\\n pass\",\n \"def mapdata():\\n return getmapdata(db, MyTable)\",\n \"def _do_mapping(self):\\n\\n distro = None\\n versions = None\\n flavor = None\\n\\n try:\\n distro = self._map_name(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\\n flavor = self._map_flavor(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\\n versions = self._map_version(self.from_distro, self.from_version, self.from_like_distro, self.found_mapping)\\n return [DistroTuple(distro=distro, version=v, flavor=flavor) for v in versions]\\n except:\\n log.exception(\\n 'Failed to fully construct the mapped distro from: {}, {}, {}'.format(self.from_distro,\\n self.from_version,\\n self.from_like_distro))\\n raise\",\n \"def map(self, function):\\n pass\",\n \"def udcall_map_next(*args):\\n return _ida_hexrays.udcall_map_next(*args)\",\n \"def call(self) -> List[Dict]:\",\n \"def get_map(self):\\n return self.get_raw_ys()\",\n \"def after_map(self, map):\\n return map\",\n \"def after_map(self, map):\\n return map\",\n \"def map(z):\\n pass\",\n \"def MAP(self):\\n return self.__map\",\n \"def mapped(self, *args, **kwargs): # real signature unknown\\r\\n pass\",\n \"def mapper() -> Callable[[str], Pin]:\",\n \"def multi_mapping(func_name, arg_value_pairs, module_name = \\\"__main__\\\"):\\n func, arg_names = get_function_args(module_name = module_name, function_name = func_name)\\n \\n return list(map(lambda arg_value_pair: call_func_dynamically(function_name = func_name, \\n argument_names = arg_names, \\n arg_value_pair = arg_value_pair) ,\\n arg_value_pairs))\",\n \"def getMappedInfo(self):\\n \\n return self.mapped_info\",\n \"def _map___iter__(self):\\n return self.iterkeys()\",\n \"def receiverMapping():\",\n \"def udcall_map_second(*args):\\n return _ida_hexrays.udcall_map_second(*args)\",\n \"def _get_mapper_0(model):\\n # build the maps\\n eids_all = (\\n list(model.elements.keys()) +\\n list(model.masses.keys()) +\\n list(model.rigid_elements.keys())\\n )\\n eid_map = {eid : eid for eid in eids_all}\\n nid_map = {nid : nid for nid in model.point_ids}\\n cid_map = {cid : cid for cid in model.coord_ids}\\n mid_map = {mid : mid for mid in model.material_ids}\\n spc_map = _dicts_key_to_key((model.spcs, model.spcadds))\\n mpc_map = _dicts_key_to_key((model.mpcs, model.mpcadds))\\n method_map = _dict_key_to_key(model.methods)\\n properties_map = _dict_key_to_key(model.properties)\\n rigid_elements_map = _dict_key_to_key(model.rigid_elements)\\n cmethod_map = _dict_key_to_key(model.cMethods)\\n flfact_map = _dict_key_to_key(model.flfacts)\\n flutter_map = _dict_key_to_key(model.flutters)\\n caero_map = _dict_key_to_key(model.caeros)\\n freq_map = _dict_key_to_key(model.frequencies)\\n\\n dload_map = _dicts_key_to_key((model.dload_entries, model.dloads))\\n load_map = _dicts_key_to_key((model.loads, model.load_combinations))\\n lseq_map = load_map # wrong???\\n temp_map = load_map # wrong???\\n\\n tstep_map = _dict_key_to_key(model.tsteps)\\n tstepnl_map = _dict_key_to_key(model.tstepnls)\\n suport1_map = _dict_key_to_key(model.suport1)\\n #suport_map = {}\\n\\n nlparm_map = _dict_key_to_key(model.nlparms)\\n #nlpci_map = _dict_key_to_key(model.nlpcis)\\n table_sdamping_map = _dict_key_to_key(model.tables_sdamping)\\n dconadd_map = _dict_key_to_key(model.dconadds)\\n dconstr_map = _dict_key_to_key(model.dconstrs)\\n dessub_map = dconadd_map\\n for key, value in dconstr_map.items():\\n if key in dessub_map:\\n raise NotImplementedError()\\n dessub_map[key] = value\\n dresp_map = _dict_key_to_key(model.dresps)\\n gust_map = _dict_key_to_key(model.gusts)\\n trim_map = _dict_key_to_key(model.trims)\\n tic_map = _dict_key_to_key(model.tics)\\n csschd_map = _dict_key_to_key(model.csschds)\\n tranfer_function_map = _dict_key_to_key(model.transfer_functions)\\n\\n mapper = {\\n 'elements' : eid_map,\\n 'nodes' : nid_map,\\n 'coords' : cid_map,\\n 'materials' : mid_map,\\n 'properties' : properties_map,\\n 'rigid_elements': rigid_elements_map,\\n 'spcs' : spc_map,\\n 'mpcs' : mpc_map,\\n 'METHOD' : method_map,\\n 'CMETHOD' : cmethod_map,\\n 'FLFACT' : flfact_map,\\n 'FMETHOD' : flutter_map,\\n 'caeros' : caero_map,\\n 'FREQUENCY' : freq_map,\\n\\n 'DLOAD' : dload_map,\\n 'LOAD' : load_map,\\n 'LOADSET' : lseq_map,\\n 'TSTEP' : tstep_map,\\n 'TSTEPNL' : tstepnl_map,\\n 'SUPORT1' : suport1_map,\\n 'NLPARM' : nlparm_map,\\n 'SDAMPING' : table_sdamping_map,\\n 'DESSUB' : dessub_map,\\n 'DESOBJ' : dresp_map,\\n 'GUST' : gust_map,\\n 'TRIM' : trim_map,\\n 'IC' : tic_map,\\n 'CSSCHD' : csschd_map,\\n 'TFL' : tranfer_function_map,\\n #'DESSUB' : dessub_map,\\n # bad...\\n 'TEMPERATURE(LOAD)' : temp_map,\\n 'TEMPERATURE(INITIAL)' : temp_map,\\n #'DATAREC' : datarec_map,\\n #'ADAPT' : adapt_map,\\n #'SUPER' : super_map,\\n #'BOUTPUT' : boutput_map,\\n #'OUTRCV' : outrcv_map,\\n }\\n\\n return mapper\",\n \"def getInfo():\",\n \"def test_core_functionality(self):\\n # Test typing\\n self.run_map_collection(\\n _map_collection=self.example_map\\n )\",\n \"def __call__(self):\\n return self._main._values()\",\n \"def get_map(self):\\n return self.map\",\n \"def get_map(self) -> list:\\n return self.map_obstacle\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('ANAP').get('abstractTypes')\\n exolinks = globalMap.get('ANAP').get('exolinks')\\n\\n # DataType GraphicsHandlerType\\n currentMap = {}\\n abstractTypes['GraphicsHandlerType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'] = currentMap\\n loadMaps['ANAP.GraphicsHandlerType'] = currentMap\\n currentMap['tag'] = 'ANAP.GraphicsHandlerType'\\n currentMap['type'] = 'simple'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001'\\n currentMap['toStr'] = 'text'\\n currentMap['cnvrt'] = 'text'\\n\\n # Class AnalysisProfile\\n currentMap = {}\\n abstractTypes['AnalysisProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'] = currentMap\\n loadMaps['ANAP.AnalysisProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'analysisProfiles'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AnalysisProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AnalysisProfile.bgColor\\n currentMap = {}\\n contentMap['bgColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.bgColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.bgColor'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00031'\\n currentMap['name'] = 'bgColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['default'] = '#FFFFFF'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute AnalysisProfile.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.fgColor\\n currentMap = {}\\n contentMap['fgColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.fgColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.fgColor'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00032'\\n currentMap['name'] = 'fgColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['default'] = '#000000'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute AnalysisProfile.font\\n currentMap = {}\\n contentMap['font'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.font'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.font'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00030'\\n currentMap['name'] = 'font'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.graphicsHandler\\n currentMap = {}\\n contentMap['graphicsHandler'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.graphicsHandler'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.graphicsHandler'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00040'\\n currentMap['name'] = 'graphicsHandler'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'Tk'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-10-03-11:26:03_00001')\\n\\n # Attribute AnalysisProfile.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute AnalysisProfile.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute AnalysisProfile.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.name'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00029'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute AnalysisProfile.panView\\n currentMap = {}\\n contentMap['panView'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.panView'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.panView'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00036'\\n currentMap['name'] = 'panView'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.sendBugReports\\n currentMap = {}\\n contentMap['sendBugReports'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.sendBugReports'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.sendBugReports'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00004'\\n currentMap['name'] = 'sendBugReports'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'maybe'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2010-11-17-16:21:33_00001')\\n\\n # Attribute AnalysisProfile.transientDialogs\\n currentMap = {}\\n contentMap['transientDialogs'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.transientDialogs'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientDialogs'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00037'\\n currentMap['name'] = 'transientDialogs'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.transientWindows\\n currentMap = {}\\n contentMap['transientWindows'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.transientWindows'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.transientWindows'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00038'\\n currentMap['name'] = 'transientWindows'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.twoCharShortcuts\\n currentMap = {}\\n contentMap['twoCharShortcuts'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.twoCharShortcuts'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.twoCharShortcuts'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00039'\\n currentMap['name'] = 'twoCharShortcuts'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.useCrosshair\\n currentMap = {}\\n contentMap['useCrosshair'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.useCrosshair'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.useCrosshair'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00034'\\n currentMap['name'] = 'useCrosshair'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = True\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.useGlobalShortcuts\\n currentMap = {}\\n contentMap['useGlobalShortcuts'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.useGlobalShortcuts'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.useGlobalShortcuts'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00035'\\n currentMap['name'] = 'useGlobalShortcuts'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute AnalysisProfile.userEmail\\n currentMap = {}\\n contentMap['userEmail'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userEmail'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userEmail'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00003'\\n currentMap['name'] = 'userEmail'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute AnalysisProfile.userName\\n currentMap = {}\\n contentMap['userName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userName'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00001'\\n currentMap['name'] = 'userName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.userOrganisation\\n currentMap = {}\\n contentMap['userOrganisation'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.userOrganisation'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.userOrganisation'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2010-11-17-16:21:37_00002'\\n currentMap['name'] = 'userOrganisation'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute AnalysisProfile.webBrowser\\n currentMap = {}\\n contentMap['webBrowser'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.webBrowser'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.webBrowser'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00033'\\n currentMap['name'] = 'webBrowser'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role AnalysisProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role AnalysisProfile.colorSchemes\\n currentMap = {}\\n contentMap['colorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.colorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.colorSchemes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00026'\\n currentMap['name'] = 'colorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.macros\\n currentMap = {}\\n contentMap['macros'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.macros'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.macros'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00022'\\n currentMap['name'] = 'macros'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.marksColor\\n currentMap = {}\\n contentMap['marksColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.marksColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.marksColor'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00028'\\n currentMap['name'] = 'marksColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['implSkip'] = True\\n currentMap['copyOverride'] = True\\n\\n # Role AnalysisProfile.refExpProfiles\\n currentMap = {}\\n contentMap['refExpProfiles'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.refExpProfiles'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.refExpProfiles'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00024'\\n currentMap['name'] = 'refExpProfiles'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.residueProfiles\\n currentMap = {}\\n contentMap['residueProfiles'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.residueProfiles'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.residueProfiles'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00020'\\n currentMap['name'] = 'residueProfiles'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('ANAP').get('abstractTypes')\\n\\n # Role AnalysisProfile.rulersColor\\n currentMap = {}\\n contentMap['rulersColor'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'] = currentMap\\n loadMaps['ANAP.AnalysisProfile.rulersColor'] = currentMap\\n currentMap['tag'] = 'ANAP.AnalysisProfile.rulersColor'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00027'\\n currentMap['name'] = 'rulersColor'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['implSkip'] = True\\n currentMap['copyOverride'] = True\\n # End of AnalysisProfile\\n\\n currentMap = abstractTypes.get('AnalysisProfile')\\n aList = ['createdBy', 'graphicsHandler', 'guid', 'isModifiable', 'lastUnlockedBy', 'name', 'panView', 'sendBugReports', 'transientDialogs', 'transientWindows', 'twoCharShortcuts', 'useCrosshair', 'useGlobalShortcuts', 'userEmail', 'webBrowser']\\n currentMap['headerAttrs'] = aList\\n aList = ['bgColor', 'fgColor', 'font', 'userName', 'userOrganisation', 'marksColor', 'rulersColor']\\n currentMap['simpleAttrs'] = aList\\n aList = ['residueProfiles', 'refExpProfiles', 'macros', 'colorSchemes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['colorSchemes', 'macros', 'refExpProfiles', 'residueProfiles']\\n currentMap['children'] = aList\\n\\n # Class ColorScheme\\n currentMap = {}\\n abstractTypes['ColorScheme'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'] = currentMap\\n loadMaps['ANAP.ColorScheme'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'colorSchemes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ColorScheme.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ColorScheme.colors\\n currentMap = {}\\n contentMap['colors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'] = currentMap\\n loadMaps['ANAP.ColorScheme.colors'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme.colors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00043'\\n currentMap['name'] = 'colors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute ColorScheme.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'] = currentMap\\n loadMaps['ANAP.ColorScheme.name'] = currentMap\\n currentMap['tag'] = 'ANAP.ColorScheme.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00007'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role ColorScheme.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of ColorScheme\\n\\n currentMap = abstractTypes.get('ColorScheme')\\n aList = ['colors', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class Macro\\n currentMap = {}\\n abstractTypes['Macro'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'] = currentMap\\n loadMaps['ANAP.Macro'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'macros'\\n currentMap['objkey'] = 'serial'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Macro.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Macro.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'] = currentMap\\n loadMaps['ANAP.Macro.details'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00005'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute Macro.function\\n currentMap = {}\\n contentMap['function'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'] = currentMap\\n loadMaps['ANAP.Macro.function'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.function'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00002'\\n currentMap['name'] = 'function'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute Macro.isInMenu\\n currentMap = {}\\n contentMap['isInMenu'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'] = currentMap\\n loadMaps['ANAP.Macro.isInMenu'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.isInMenu'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00005'\\n currentMap['name'] = 'isInMenu'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute Macro.isInMouseMenu\\n currentMap = {}\\n contentMap['isInMouseMenu'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'] = currentMap\\n loadMaps['ANAP.Macro.isInMouseMenu'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.isInMouseMenu'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-29-13:48:16_00006'\\n currentMap['name'] = 'isInMouseMenu'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = False\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00028')\\n\\n # Attribute Macro.module\\n currentMap = {}\\n contentMap['module'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'] = currentMap\\n loadMaps['ANAP.Macro.module'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.module'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00003'\\n currentMap['name'] = 'module'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute Macro.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'] = currentMap\\n loadMaps['ANAP.Macro.name'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:10_00001'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Attribute Macro.ordering\\n currentMap = {}\\n contentMap['ordering'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'] = currentMap\\n loadMaps['ANAP.Macro.ordering'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.ordering'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00004'\\n currentMap['name'] = 'ordering'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['default'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Macro.path\\n currentMap = {}\\n contentMap['path'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'] = currentMap\\n loadMaps['ANAP.Macro.path'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.path'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00001'\\n currentMap['name'] = 'path'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00003')\\n\\n # Attribute Macro.serial\\n currentMap = {}\\n contentMap['serial'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'] = currentMap\\n loadMaps['ANAP.Macro.serial'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.serial'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:09_00001'\\n currentMap['name'] = 'serial'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Macro.shortcut\\n currentMap = {}\\n contentMap['shortcut'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'] = currentMap\\n loadMaps['ANAP.Macro.shortcut'] = currentMap\\n currentMap['tag'] = 'ANAP.Macro.shortcut'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-17-15:11:12_00006'\\n currentMap['name'] = 'shortcut'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role Macro.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of Macro\\n\\n currentMap = abstractTypes.get('Macro')\\n aList = ['function', 'isInMenu', 'isInMouseMenu', 'module', 'ordering', 'serial', 'shortcut']\\n currentMap['headerAttrs'] = aList\\n aList = ['details', 'name', 'path']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class RefExpProfile\\n currentMap = {}\\n abstractTypes['RefExpProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'] = currentMap\\n loadMaps['ANAP.RefExpProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'refExpProfiles'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute RefExpProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute RefExpProfile.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'] = currentMap\\n loadMaps['ANAP.RefExpProfile.name'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00046'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Attribute RefExpProfile.peakSymbolColors\\n currentMap = {}\\n contentMap['peakSymbolColors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'] = currentMap\\n loadMaps['ANAP.RefExpProfile.peakSymbolColors'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.peakSymbolColors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00048'\\n currentMap['name'] = 'peakSymbolColors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute RefExpProfile.peakTextColors\\n currentMap = {}\\n contentMap['peakTextColors'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'] = currentMap\\n loadMaps['ANAP.RefExpProfile.peakTextColors'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.peakTextColors'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00049'\\n currentMap['name'] = 'peakTextColors'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00007')\\n\\n # Attribute RefExpProfile.refExpNames\\n currentMap = {}\\n contentMap['refExpNames'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'] = currentMap\\n loadMaps['ANAP.RefExpProfile.refExpNames'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.refExpNames'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00047'\\n currentMap['name'] = 'refExpNames'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role RefExpProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role RefExpProfile.negColorSchemes\\n currentMap = {}\\n contentMap['negColorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'] = currentMap\\n loadMaps['ANAP.RefExpProfile.negColorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.negColorSchemes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00045'\\n currentMap['name'] = 'negColorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n\\n # Role RefExpProfile.posColorSchemes\\n currentMap = {}\\n contentMap['posColorSchemes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'] = currentMap\\n loadMaps['ANAP.RefExpProfile.posColorSchemes'] = currentMap\\n currentMap['tag'] = 'ANAP.RefExpProfile.posColorSchemes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00041'\\n currentMap['name'] = 'posColorSchemes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of RefExpProfile\\n\\n currentMap = abstractTypes.get('RefExpProfile')\\n aList = ['name']\\n currentMap['headerAttrs'] = aList\\n aList = ['peakSymbolColors', 'peakTextColors', 'refExpNames', 'negColorSchemes', 'posColorSchemes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ResidueProfile\\n currentMap = {}\\n abstractTypes['ResidueProfile'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'] = currentMap\\n loadMaps['ANAP.ResidueProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'residueProfiles'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ResidueProfile.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ResidueProfile.ccpCode\\n currentMap = {}\\n contentMap['ccpCode'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'] = currentMap\\n loadMaps['ANAP.ResidueProfile.ccpCode'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.ccpCode'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00051'\\n currentMap['name'] = 'ccpCode'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ResidueProfile.guiName\\n currentMap = {}\\n contentMap['guiName'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'] = currentMap\\n loadMaps['ANAP.ResidueProfile.guiName'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.guiName'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00052'\\n currentMap['name'] = 'guiName'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003')\\n\\n # Attribute ResidueProfile.molType\\n currentMap = {}\\n contentMap['molType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'] = currentMap\\n loadMaps['ANAP.ResidueProfile.molType'] = currentMap\\n currentMap['tag'] = 'ANAP.ResidueProfile.molType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:52_00050'\\n currentMap['name'] = 'molType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024')\\n\\n # Role ResidueProfile.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of ResidueProfile\\n\\n currentMap = abstractTypes.get('ResidueProfile')\\n aList = ['ccpCode', 'guiName', 'molType']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to AnalysisProfile\\n currentMap = {}\\n exolinks['AnalysisProfile'] = currentMap\\n loadMaps['ANAP.exo-AnalysisProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-AnalysisProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00004'\\n currentMap['name'] = 'AnalysisProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.AnalysisProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to ColorScheme\\n currentMap = {}\\n exolinks['ColorScheme'] = currentMap\\n loadMaps['ANAP.exo-ColorScheme'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-ColorScheme'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00002'\\n currentMap['name'] = 'ColorScheme'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ColorScheme\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to Macro\\n currentMap = {}\\n exolinks['Macro'] = currentMap\\n loadMaps['ANAP.exo-Macro'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-Macro'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-08-11:06:22_00001'\\n currentMap['name'] = 'Macro'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.Macro\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\\n\\n # Out-of-package link to RefExpProfile\\n currentMap = {}\\n exolinks['RefExpProfile'] = currentMap\\n loadMaps['ANAP.exo-RefExpProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-RefExpProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00006'\\n currentMap['name'] = 'RefExpProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.RefExpProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037'))\\n\\n # Out-of-package link to ResidueProfile\\n currentMap = {}\\n exolinks['ResidueProfile'] = currentMap\\n loadMaps['ANAP.exo-ResidueProfile'] = currentMap\\n currentMap['tag'] = 'ANAP.exo-ResidueProfile'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2008-05-05-15:12:50_00005'\\n currentMap['name'] = 'ResidueProfile'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccpnmr.api.AnalysisProfile.ResidueProfile\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00024'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-09-12-18:31:28_00003'))\",\n \"def demo_one_map():\\n radii = [2, 5, 7.1, 0.3, 10]\\n demo_1(radii)\\n demo_2(radii)\",\n \"def making_map():\\n account = request.form['tweecount']\\n number = request.form['num_friends']\\n n_map = map(authorization(account, number))\\n return n_map\",\n \"def requires_mapping(self):\",\n \"def mapper(fun: Callable[[str], Pin], /) -> None:\",\n \"def scan(self):\\n for fn in self.map:\\n coords = list(self.map[fn].keys())\\n coords.sort()\\n for coord in coords:\\n yield fn, coord, self.map[fn][coord]\",\n \"def build_I_map(self):\\n raise NotImplementedError\",\n \"def udcall_map_first(*args):\\n return _ida_hexrays.udcall_map_first(*args)\",\n \"def map(self):\\n map_rupture(self)\",\n \"def getMapping(self):\\n self._process()\\n return self._mapping\",\n \"def demo_two_map():\\n # example using map\\n temps_c = [(\\\"Berlin\\\", 29), (\\\"Cairo\\\", 36), (\\\"Buenos Aires\\\", 19),\\n (\\\"Los Angeles\\\", 26), (\\\"Tokyo\\\", 27), (\\\"New York\\\", 28),\\n (\\\"London\\\", 22), (\\\"Beijing\\\", 32)]\\n\\n # lambda to return tuple with calculated deg. F converted from deg. C\\n c2f = lambda city_tmp: (city_tmp[0], (9.0/5.0)*city_tmp[1] + 32)\\n\\n print list(map(c2f, temps_c))\",\n \"def map(self):\\n return self.map_digis(self.group)\",\n \"def test_tuple_input(self):\\n \\n self._tuple1 = 1, 2, 3\\n self._tuple2 = 'yes', 'y', 'hey'\\n self.assertEqual(False, maps.map_list(self._tuple1))\\n self.assertEqual(False, maps.map_list(self._tuple2))\",\n \"def components_map(self):\\r\\n raise NotImplementedError\",\n \"def map(self, func):\\n return List(map(func, self))\",\n \"def get(self):\\n maps = Map.all()\\n results = [map_object.serialize() for map_object in maps]\\n return results, status.HTTP_200_OK\",\n \"def __call__(self, func, *args, **kwds):\\r\\n results = self.map(func, *args, **kwds)\\r\\n if results:\\r\\n return results[0]\",\n \"def test_map(self):\\n\\n test_cases = [\\n Case(\\n description=\\\"lists of objects\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, {\\\"title\\\": \\\"baz\\\"}],\\n args=[\\\"title\\\"],\\n kwargs={},\\n expect=[\\\"foo\\\", \\\"bar\\\", \\\"baz\\\"],\\n ),\\n Case(\\n description=\\\"missing argument\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, {\\\"title\\\": \\\"baz\\\"}],\\n args=[],\\n kwargs={},\\n expect=FilterArgumentError,\\n ),\\n Case(\\n description=\\\"too many arguments\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, {\\\"title\\\": \\\"baz\\\"}],\\n args=[\\\"title\\\", \\\"\\\"],\\n kwargs={},\\n expect=FilterArgumentError,\\n ),\\n Case(\\n description=\\\"missing property\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, {\\\"heading\\\": \\\"baz\\\"}],\\n args=[\\\"title\\\"],\\n kwargs={},\\n expect=[\\\"foo\\\", \\\"bar\\\", None],\\n ),\\n Case(\\n description=\\\"value not an array\\\",\\n val=123,\\n args=[\\\"title\\\"],\\n kwargs={},\\n expect=FilterValueError,\\n ),\\n Case(\\n description=\\\"array contains non object\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, 5, []],\\n args=[\\\"title\\\"],\\n kwargs={},\\n expect=FilterValueError,\\n ),\\n Case(\\n description=\\\"undefined left value\\\",\\n val=self.env.undefined(\\\"test\\\"),\\n args=[\\\"title\\\"],\\n kwargs={},\\n expect=[],\\n ),\\n Case(\\n description=\\\"undefined argument\\\",\\n val=[{\\\"title\\\": \\\"foo\\\"}, {\\\"title\\\": \\\"bar\\\"}, {\\\"title\\\": \\\"baz\\\"}],\\n args=[self.env.undefined(\\\"test\\\")],\\n kwargs={},\\n expect=[None, None, None],\\n ),\\n ]\\n\\n self._test(Map, test_cases)\",\n \"def __call__(self):\\n return self._main._items()\",\n \"def map(self, func):\\n return _(map(func, self._))\",\n \"def test_map_basics(self):\\n self.assertDigitizerMapBasics(self.map, self.dgroup)\",\n \"def map(self) -> global___Statement.Declaration:\",\n \"def request_map():\\n\\n rospy.loginfo(\\\"Requesting the map\\\")\\n rospy.wait_for_service('dynamic_map')\\n getMap = rospy.ServiceProxy('dynamic_map', GetMap)\\n g = getMap().map\\n\\n return g\",\n \"def __call__(self, circuit=None):\\n if isinstance(self.map, dict):\\n pass\\n elif isinstance(self.map, list):\\n self.map = dict(zip(list(\\\"q\\\" + str(i) for i in range(len(self.map))), self.map))\\n else:\\n raise_error(TypeError, \\\"Use dict or list to define mapping.\\\")\\n if circuit is not None:\\n assert_placement(circuit, self.map)\\n else:\\n assert_mapping_consistency(self.map)\\n return self.map\",\n \"def result_field_map():\\n return {\\n \\\"[run number]\\\": \\\"run_number\\\",\\n \\\"map-file\\\": \\\"map_file\\\",\\n \\\"People\\\": \\\"people\\\",\\n \\\"person_path_weight\\\": \\\"person_path_weight\\\",\\n \\\"Slow\\\": \\\"slow\\\",\\n \\\"Medium\\\": \\\"medium\\\",\\n \\\"Fast\\\": \\\"fast\\\",\\n \\\"display-path-cost?\\\": \\\"display_path_cost_p\\\",\\n \\\"add-person-spacing?\\\": \\\"add_person_spacing_p\\\",\\n \\\"people-wait?\\\": \\\"people_wait_p\\\",\\n \\\"equal-diagonal-weight?\\\": \\\"equal_diagonal_weight_p\\\",\\n \\\"Slow-Speed\\\": \\\"slow_speed\\\",\\n \\\"Medium-Speed\\\": \\\"medium_speed\\\",\\n \\\"Fast-Speed\\\": \\\"fast_speed\\\",\\n \\\"set-fire?\\\": \\\"set_fire_p\\\",\\n \\\"Fire_Speed\\\": \\\"fire_speed\\\" ,\\n \\\"mean-escape-time\\\": \\\"mean_escape_time\\\",\\n }\",\n \"def get(self) -> tuple:\",\n \"def udcall_map_new(*args):\\n return _ida_hexrays.udcall_map_new(*args)\",\n \"def _empty_mapping(self):\\r\\n return self.type2test()\",\n \"def testStepBuildStatsMap(self):\\n self._StringToMapHelper(data_types.StepBuildStatsMap, data_types.BuildStats)\",\n \"def fetch_map(self, page, part):\\n\\n source = self.mapUrl.replace('PAGE', str(page)).replace('PART', str(part))\\n html = http_get(source).replace(\\\"\\\\n\\\", \\\"\\\")\\n map_string = html.split('<map name=\\\"map1\\\">')[1].split('</map>')[0]\\n p = re.compile('<area COORDS=\\\"(?P<x1>\\\\\\\\d+),(?P<y1>\\\\\\\\d+),(?P<x2>\\\\\\\\d+),(?P<y2>\\\\\\\\d+),?\\\" href=\\\"popupTelevideo.jsp\\\\?p=(?P<page>\\\\\\\\d+)&s=(?P<part>\\\\\\\\d+)&r=Nazionale\\\">')\\n map = [(int(a[0]) * self.RESIZE_FACTOR, int(a[1]) * self.RESIZE_FACTOR, int(a[2]) * self.RESIZE_FACTOR, int(a[3]) * self.RESIZE_FACTOR, int(a[4]), int(a[5]) + 1) for a in p.findall(map_string)]\\n return map\",\n \"def mapping(self):\\n return self.request('_mapping', pylastica.request.Request.GET).data\",\n \"def _doMap(self, func, iterable):\\n name = \\\"Mapper\\\"\\n sys.stderr.write(\\\"Master[%s phase]: starting\\\\n\\\" % name)\\n pipes = [mp.Pipe() for _ in range(self.num_workers)]\\n proc = [mp.Process(target=spawn_mapper(func), name=name, args=(q,)) for q in pipes]\\n for p in proc:\\n p.daemon = True\\n p.start()\\n for output_p, input_p in pipes:\\n input_p.close() # we don't need to read from the pipes\\n qi = 0\\n for item in iterable:\\n pipes[qi][0].send(item)\\n qi = (qi+1) % self.num_workers\\n for q,_ in pipes:\\n q.send(None) # add termination tokens\\n q.close()\\n for p in proc:\\n p.join()\\n sys.stderr.write(\\\"Master[%s phase]: ended..\\\\n\\\" % name)\",\n \"def MakeFieldmaps(self):\\n if self.verbose:\\n print 'Compute fieldmaps.'\\n for entry in self.info:\\n if self.info[entry]['type'] == 'fmap':\\n if self.info[entry]['imgfile'] == None:\\n# Fieldmap data not found.\\n return\\n# Make a magnitude image for use in checking registration.\\n cmd = 'convert_file -f0 -m0 %s %s nii' % \\\\\\n (entry, self.info[entry]['magfile'])\\n self.CheckExec(cmd, [self.info[entry]['magfile'] + '.nii'])\\n\\n# Make fieldmap. Use separate loop in case make_fmap aborts.\\n for entry in self.info:\\n if self.info[entry]['type'] == 'fmap':\\n fmapname = self.info[entry]['imgfile']\\n if not os.path.exists('%s.nii' % fmapname) or self.redo:\\n# Couldn't find or existing fmap, compute a new one.\\n if self.verbose:\\n extra_args = '-v'\\n else:\\n extra_args = ''\\n if self.info[entry]['correct_fmap_phase'] == 'force':\\n extra_args += ' --force-slicecorr'\\n elif self.info[entry]['correct_fmap_phase'] == 'omit':\\n extra_args += ' --omit-slicecorr'\\n cmd = 'make_fmap %s %s %s' % (extra_args, entry, fmapname)\\n# error = self.ExecCmd(cmd, halt_on_error=False)\\n if self.no_fmapcorr:\\n halt_on_error = False\\n else:\\n halt_on_error = True\\n error = self.CheckExec(cmd, ['%s.nii' % fmapname], \\\\\\n halt_on_error=halt_on_error)\\n if error:\\n self.info[entry]['valid'] = False\\n del self.fmaps[entry]\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CHEL').get('abstractTypes')\\n exolinks = globalMap.get('CHEL').get('exolinks')\\n\\n # DataType HalfLifeType\\n currentMap = {}\\n abstractTypes['HalfLifeType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'] = currentMap\\n loadMaps['CHEL.HalfLifeType'] = currentMap\\n currentMap['tag'] = 'CHEL.HalfLifeType'\\n currentMap['type'] = 'simple'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002'\\n currentMap['toStr'] = 'text'\\n currentMap['cnvrt'] = 'text'\\n\\n # Class ChemElement\\n currentMap = {}\\n abstractTypes['ChemElement'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'] = currentMap\\n loadMaps['CHEL.ChemElement'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemElements'\\n currentMap['objkey'] = 'symbol'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemElement.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemElement.atomNumber\\n currentMap = {}\\n contentMap['atomNumber'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'] = currentMap\\n loadMaps['CHEL.ChemElement.atomNumber'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.atomNumber'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00017'\\n currentMap['name'] = 'atomNumber'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['proc'] = 'direct'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute ChemElement.atomicRadius\\n currentMap = {}\\n contentMap['atomicRadius'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'] = currentMap\\n loadMaps['CHEL.ChemElement.atomicRadius'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.atomicRadius'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00018'\\n currentMap['name'] = 'atomicRadius'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.covalentRadius\\n currentMap = {}\\n contentMap['covalentRadius'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'] = currentMap\\n loadMaps['CHEL.ChemElement.covalentRadius'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.covalentRadius'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00019'\\n currentMap['name'] = 'covalentRadius'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.mass\\n currentMap = {}\\n contentMap['mass'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'] = currentMap\\n loadMaps['CHEL.ChemElement.mass'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.mass'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00020'\\n currentMap['name'] = 'mass'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute ChemElement.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'] = currentMap\\n loadMaps['CHEL.ChemElement.name'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00021'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\\n\\n # Attribute ChemElement.symbol\\n currentMap = {}\\n contentMap['symbol'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'] = currentMap\\n loadMaps['CHEL.ChemElement.symbol'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.symbol'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00015'\\n currentMap['name'] = 'symbol'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055')\\n\\n # Role ChemElement.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemElement.isotopes\\n currentMap = {}\\n contentMap['isotopes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'] = currentMap\\n loadMaps['CHEL.ChemElement.isotopes'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElement.isotopes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00004'\\n currentMap['name'] = 'isotopes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\\n # End of ChemElement\\n\\n currentMap = abstractTypes.get('ChemElement')\\n aList = ['atomNumber', 'atomicRadius', 'covalentRadius', 'mass', 'name', 'symbol']\\n currentMap['headerAttrs'] = aList\\n aList = ['isotopes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['isotopes']\\n currentMap['children'] = aList\\n\\n # Class ChemElementStore\\n currentMap = {}\\n abstractTypes['ChemElementStore'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'] = currentMap\\n loadMaps['CHEL.ChemElementStore'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'chemElementStores'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ChemElementStore.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ChemElementStore.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute ChemElementStore.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute ChemElementStore.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'] = currentMap\\n loadMaps['CHEL.ChemElementStore.name'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00024'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role ChemElementStore.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ChemElementStore.chemElements\\n currentMap = {}\\n contentMap['chemElements'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'] = currentMap\\n loadMaps['CHEL.ChemElementStore.chemElements'] = currentMap\\n currentMap['tag'] = 'CHEL.ChemElementStore.chemElements'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00023'\\n currentMap['name'] = 'chemElements'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CHEL').get('abstractTypes')\\n # End of ChemElementStore\\n\\n currentMap = abstractTypes.get('ChemElementStore')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\\n currentMap['headerAttrs'] = aList\\n aList = ['name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['chemElements', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['chemElements']\\n currentMap['children'] = aList\\n\\n # Class Isotope\\n currentMap = {}\\n abstractTypes['Isotope'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'] = currentMap\\n loadMaps['CHEL.Isotope'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'isotopes'\\n currentMap['objkey'] = 'massNumber'\\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Isotope.abundance\\n currentMap = {}\\n contentMap['abundance'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'] = currentMap\\n loadMaps['CHEL.Isotope.abundance'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.abundance'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00011'\\n currentMap['name'] = 'abundance'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00058')\\n\\n # Attribute Isotope.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Isotope.gyroMagneticRatio\\n currentMap = {}\\n contentMap['gyroMagneticRatio'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'] = currentMap\\n loadMaps['CHEL.Isotope.gyroMagneticRatio'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.gyroMagneticRatio'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00008'\\n currentMap['name'] = 'gyroMagneticRatio'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.halfLife\\n currentMap = {}\\n contentMap['halfLife'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'] = currentMap\\n loadMaps['CHEL.Isotope.halfLife'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLife'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00001'\\n currentMap['name'] = 'halfLife'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\\n\\n # Attribute Isotope.halfLifeError\\n currentMap = {}\\n contentMap['halfLifeError'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'] = currentMap\\n loadMaps['CHEL.Isotope.halfLifeError'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLifeError'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00002'\\n currentMap['name'] = 'halfLifeError'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:54_00007')\\n\\n # Attribute Isotope.halfLifeType\\n currentMap = {}\\n contentMap['halfLifeType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'] = currentMap\\n loadMaps['CHEL.Isotope.halfLifeType'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.halfLifeType'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2007-06-07-18:18:13_00003'\\n currentMap['name'] = 'halfLifeType'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['default'] = 'unknown'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2007-06-07-18:18:10_00002')\\n\\n # Attribute Isotope.magneticMoment\\n currentMap = {}\\n contentMap['magneticMoment'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'] = currentMap\\n loadMaps['CHEL.Isotope.magneticMoment'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.magneticMoment'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00013'\\n currentMap['name'] = 'magneticMoment'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.mass\\n currentMap = {}\\n contentMap['mass'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'] = currentMap\\n loadMaps['CHEL.Isotope.mass'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.mass'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00010'\\n currentMap['name'] = 'mass'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.massNumber\\n currentMap = {}\\n contentMap['massNumber'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'] = currentMap\\n loadMaps['CHEL.Isotope.massNumber'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.massNumber'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00007'\\n currentMap['name'] = 'massNumber'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['proc'] = 'direct'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032')\\n\\n # Attribute Isotope.quadrupoleMoment\\n currentMap = {}\\n contentMap['quadrupoleMoment'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'] = currentMap\\n loadMaps['CHEL.Isotope.quadrupoleMoment'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.quadrupoleMoment'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00014'\\n currentMap['name'] = 'quadrupoleMoment'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.receptivity\\n currentMap = {}\\n contentMap['receptivity'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'] = currentMap\\n loadMaps['CHEL.Isotope.receptivity'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.receptivity'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00012'\\n currentMap['name'] = 'receptivity'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00031')\\n\\n # Attribute Isotope.spin\\n currentMap = {}\\n contentMap['spin'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'] = currentMap\\n loadMaps['CHEL.Isotope.spin'] = currentMap\\n currentMap['tag'] = 'CHEL.Isotope.spin'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:12_00009'\\n currentMap['name'] = 'spin'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00037')\\n\\n # Role Isotope.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of Isotope\\n\\n currentMap = abstractTypes.get('Isotope')\\n aList = ['abundance', 'gyroMagneticRatio', 'halfLife', 'halfLifeError', 'halfLifeType', 'magneticMoment', 'mass', 'massNumber', 'quadrupoleMoment', 'receptivity', 'spin']\\n currentMap['headerAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to ChemElement\\n currentMap = {}\\n exolinks['ChemElement'] = currentMap\\n loadMaps['CHEL.exo-ChemElement'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-ChemElement'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00004'\\n currentMap['name'] = 'ChemElement'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElement\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\\n\\n # Out-of-package link to ChemElementStore\\n currentMap = {}\\n exolinks['ChemElementStore'] = currentMap\\n loadMaps['CHEL.exo-ChemElementStore'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-ChemElementStore'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00005'\\n currentMap['name'] = 'ChemElementStore'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.ChemElementStore\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to Isotope\\n currentMap = {}\\n exolinks['Isotope'] = currentMap\\n loadMaps['CHEL.exo-Isotope'] = currentMap\\n currentMap['tag'] = 'CHEL.exo-Isotope'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:19:49_00003'\\n currentMap['name'] = 'Isotope'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.molecule.ChemElement.Isotope\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00055'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00032'))\",\n \"def get_all_locations(self):\",\n \"def print_current_mappings(self):\\n for mapped_name in self.__mapped_names:\\n func = getattr(self, mapped_name)\\n name = f'{func.__module__}.{func.__name__}'\\n print(f'* {mapped_name} -- {name}')\",\n \"def map(self, app, node):\",\n \"def map(self) -> Map:\\n return self._map\",\n \"def _mapping(self):\\n return [('message.received', self.on_new_message), \\\\\\n ('message.read.prevent', self.can_not_read)]\",\n \"def _SetFmapInfo(self):\\n for epi in self.pfiles + self.epirt_paths:\\n self.info[epi]['fmapname'] = None\\n self.info[epi]['fmap_entry'] = None\\n for entry in self.entry_map['fmap']:\\n fmap_name = self.info[entry]['imgfile'] + self.info[entry]['suffix']\\n if self.info[entry]['plane'] == self.info[epi]['plane']:\\n# Use the fieldmap acquired at the same plane.\\n self.info[epi]['fmapname'] = fmap_name\\n self.info[epi]['fmap_entry'] = entry\\n break\\n else:\\n# for fmap in self.fmaps.keys():\\n for entry in self.entry_map['fmap']:\\n# No fmap at same orientation, look for fmaps in other planes.\\n# There won't be more than one, so it isn't much of a choice.\\n fmap_name = self.info[entry]['imgfile'] + \\\\\\n self.info[entry]['suffix']\\n if self.info[entry]['plane'] == 'sagittal':\\n self.info[epi]['fmapname'] = fmap_name\\n self.info[epi]['fmap_entry'] = entry\\n break\\n elif self.info[entry]['plane'] == 'axial':\\n self.info[epi]['fmapname'] = fmap_name\\n self.info[epi]['fmap_entry'] = entry\\n break\\n elif self.info[entry]['plane'] == 'coronal':\\n self.info[epi]['fmapname'] = fmap_name\\n self.info[epi]['fmap_entry'] = entry\\n break\\n elif self.info[entry]['plane'] == 'oblique':\\n self.info[epi]['fmapname'] = fmap_name\\n self.info[epi]['fmap_entry'] = entry\\n self.info[epi]['plane'] = 'oblique'\\n break\",\n \"def map_profile_info(profile):\\n result = map(\\n lambda p: {\\n 'callcount': p.callcount,\\n 'time': p.totaltime,\\n 'name': p.code if isinstance(p.code, str) else p.code.co_name,\\n 'file': None if isinstance(p.code, str) else p.code.co_filename},\\n profile.getstats())\\n return result\",\n \"def tuple_map(x):\\n return x * 2\",\n \"def get_mapping(proj,exp):\\n response = do_method(\\\"experiment.info\\\",\\n {\\\"proj\\\":proj,\\\"exp\\\":exp,\\\"aspect\\\":\\\"mapping\\\"})\\n check_response(response)\\n return response['value']\",\n \"def map_generate_tuple(*args):\\n key, func, arg = args[0][0], args[0][1], args[0][2]\\n return (key, func(*arg))\",\n \"def info() -> Dict[str, Any]:\",\n \"def get_forward_mapping(self):\",\n \"def get_MAP(prior,likelihood):\\n pr = np.array(prior)\\n ll = np.array(likelihood)\\n\\n ps = np.dot(pr * ll)\\n ps /= np.sum(ps)\\n\\n map_idx = np.argmax(ps)\\n return (map_idx,ps)\",\n \"def get_info(cls, icao_id: str) -> Tuple[str, str]:\\n if len(cls.mapping) == 0:\\n cls._generate_mapping()\\n return cls.mapping.get(icao_id.lower(), ('Unknown', 'Unknown'))\",\n \"def _get_mapVersion(self):\\n return self.__mapVersion\",\n \"def fetchGeoData():\\n if request.method ==\\\"POST\\\":\\n result = {}\\n if request.get_json():\\n post_requests = request.get_json()\\n print(post_requests)\\n result = db.getmapdata(post_requests['attr']) \\n return result\",\n \"def parse_mapping_page(self, id, body):\\n info = {}\\n info['original'] = self.__re_search(body, *self.regx['original'])\\n info['save'] = self.__re_search(body, *self.regx['save'])\\n info['price'] = self.__re_search(body, *self.regx['price'])\\n info['rebate'] = self.__re_search(body, *self.regx['rebate'])\\n return info\",\n \"def map_value(self) -> global___Expression.MapValue:\",\n \"def map(iteratee, *seqs):\\n return _map(fnc.iteratee(iteratee), *seqs)\",\n \"def testBuilderStepMap(self):\\n self._StringToMapHelper(data_types.BuilderStepMap,\\n data_types.StepBuildStatsMap)\",\n \"def get_map(self):\\n\\n self.mp = defaultdict(lambda : ord('x'))\\n y, x = 0, 0\\n while True:\\n cond, output = self.ic()\\n\\n if cond: break\\n # New row of the print out\\n if output == 10:\\n y += 1\\n x = 0\\n # Assign the value to the map\\n else:\\n self.mp[y,x] = output\\n x += 1\\n \\n return self.mp\",\n \"def map():\\n return render_template('map.html')\",\n \"def test_name_to_func_map(self):\\n test_file = 'tests/commentsForProtobuf'\\n options = Namespace()\\n options.already = set()\\n options.ex_re = None\\n options.map_holder = MapHolder()\\n options.verbose = False\\n\\n lines, sloc = count_lines_protobuf(test_file, options, 'py')\\n self.assertEqual(lines, 71)\\n self.assertEqual(sloc, 46)\",\n \"def udcall_map_find(*args):\\n return _ida_hexrays.udcall_map_find(*args)\",\n \"def _getMappingInfo(\\n\\textractionCtx: ExtractionContext\\n) -> List[_MappingInfo]:\\n\\tdyldCtx = extractionCtx.dyldCtx\\n\\tlogger = extractionCtx.logger\\n\\n\\tmappingInfo = []\\n\\n\\tif dyldCtx.header.slideInfoOffsetUnused:\\n\\t\\t# Assume the legacy case with no sub caches, and only one slide info\\n\\t\\tif dyldCtx.hasSubCaches():\\n\\t\\t\\tlogger.error(\\\"Legacy slide info with sub caches.\\\")\\n\\t\\t\\tpass\\n\\n\\t\\t# the version is encoded as the first uint32 field\\n\\t\\tslideInfoOff = dyldCtx.header.slideInfoOffsetUnused\\n\\t\\tslideInfoVer = dyldCtx.readFormat(\\\"<I\\\", slideInfoOff)[0]\\n\\n\\t\\tif slideInfoVer not in _SlideInfoMap:\\n\\t\\t\\tlogger.error(\\\"Unknown slide info version: \\\" + slideInfoVer)\\n\\t\\t\\treturn None\\n\\n\\t\\t# Assume that only the second mapping has slide info\\n\\t\\tmapping = dyldCtx.mappings[1][0]\\n\\t\\tslideInfo = _SlideInfoMap[slideInfoVer](dyldCtx.file, slideInfoOff)\\n\\t\\tmappingInfo.append(_MappingInfo(mapping, slideInfo, dyldCtx))\\n\\t\\tpass\\n\\n\\telse:\\n\\t\\tfor mapping, context in dyldCtx.mappings:\\n\\t\\t\\tif not context.headerContainsField(\\\"mappingWithSlideOffset\\\"):\\n\\t\\t\\t\\tlogger.error(\\\"Unable to pair mapping with slide info.\\\")\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# Get the expanded mapping info\\n\\t\\t\\tmapI = context.mappings.index((mapping, context))\\n\\t\\t\\tmapOff = (\\n\\t\\t\\t\\tcontext.header.mappingWithSlideOffset\\n\\t\\t\\t\\t+ mapI * dyld_cache_mapping_and_slide_info.SIZE\\n\\t\\t\\t)\\n\\n\\t\\t\\tmapping = dyld_cache_mapping_and_slide_info(context.file, mapOff)\\n\\t\\t\\tif mapping.slideInfoFileOffset:\\n\\t\\t\\t\\tslideInfoVer = context.readFormat(\\\"<I\\\", mapping.slideInfoFileOffset)[0]\\n\\n\\t\\t\\t\\tif slideInfoVer not in _SlideInfoMap:\\n\\t\\t\\t\\t\\tlogger.error(\\\"Unknown slide info version: \\\" + slideInfoVer)\\n\\t\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t\\tslideInfo = _SlideInfoMap[slideInfoVer](\\n\\t\\t\\t\\t\\tcontext.file,\\n\\t\\t\\t\\t\\tmapping.slideInfoFileOffset\\n\\t\\t\\t\\t)\\n\\t\\t\\t\\tmappingInfo.append(_MappingInfo(mapping, slideInfo, context))\\n\\t\\t\\t\\tpass\\n\\t\\t\\tpass\\n\\t\\tpass\\n\\n\\treturn mappingInfo\",\n \"def Maps(num_maps, num_cities):\\n return tuple(Cities(num_cities, seed=(m, num_cities))\\n for m in range(num_maps))\",\n \"def map():\\n\\n return render_template(\\\"map.html\\\")\",\n \"def makeMapping(globalMap):\\n \\n from memops.xml.Implementation import bool2str, str2bool\\n\\n # Set up top level dictionaries\\n loadMaps = globalMap.get('loadMaps')\\n mapsByGuid = globalMap.get('mapsByGuid')\\n\\n abstractTypes = globalMap.get('CLAS').get('abstractTypes')\\n exolinks = globalMap.get('CLAS').get('exolinks')\\n\\n # Class AbstractCategory\\n currentMap = {}\\n abstractTypes['AbstractCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'] = currentMap\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:19:17_00001'\\n currentMap['eType'] = 'cplx'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.AbstractCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute AbstractCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute AbstractCategory.details\\n currentMap = {}\\n contentMap['details'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'] = currentMap\\n loadMaps['CLAS.AbstractCategory.details'] = currentMap\\n currentMap['tag'] = 'CLAS.AbstractCategory.details'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001'\\n currentMap['name'] = 'details'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Attribute AbstractCategory.name\\n currentMap = {}\\n contentMap['name'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'] = currentMap\\n loadMaps['CLAS.AbstractCategory.name'] = currentMap\\n currentMap['tag'] = 'CLAS.AbstractCategory.name'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014'\\n currentMap['name'] = 'name'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role AbstractCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of AbstractCategory\\n\\n currentMap = abstractTypes.get('AbstractCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class Classification\\n currentMap = {}\\n abstractTypes['Classification'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'] = currentMap\\n loadMaps['CLAS.Classification'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'classifications'\\n currentMap['isTop'] = True\\n currentMap['objkey'] = 'namingSystem'\\n currentMap['class'] = ccp.api.lims.Classification.Classification\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute Classification.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute Classification.createdBy\\n contentMap['createdBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00002__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.guid\\n contentMap['guid'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:26_00002')\\n\\n # Attribute Classification.isModifiable\\n contentMap['isModifiable'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-17-14:16:26_00010__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.lastUnlockedBy\\n contentMap['lastUnlockedBy'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:00:59_00003__www.ccpn.ac.uk_Fogh_2007-10-03-14:53:27_00001__www.ccpn.ac.uk_Fogh_2006-09-14-16:28:57_00002')\\n\\n # Attribute Classification.namingSystem\\n currentMap = {}\\n contentMap['namingSystem'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'] = currentMap\\n loadMaps['CLAS.Classification.namingSystem'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.namingSystem'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00013'\\n currentMap['name'] = 'namingSystem'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 1\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033')\\n\\n # Role Classification.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role Classification.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'] = currentMap\\n loadMaps['CLAS.Classification.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.experimentTypes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00002'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.hazardPhrases\\n currentMap = {}\\n contentMap['hazardPhrases'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'] = currentMap\\n loadMaps['CLAS.Classification.hazardPhrases'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.hazardPhrases'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00006'\\n currentMap['name'] = 'hazardPhrases'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.holderCategorys\\n currentMap = {}\\n contentMap['holderCategorys'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'] = currentMap\\n loadMaps['CLAS.Classification.holderCategorys'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.holderCategorys'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:33:23_00002'\\n currentMap['name'] = 'holderCategorys'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.instrumentTypes\\n currentMap = {}\\n contentMap['instrumentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'] = currentMap\\n loadMaps['CLAS.Classification.instrumentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.instrumentTypes'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:33_00001'\\n currentMap['name'] = 'instrumentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.sampleCategories\\n currentMap = {}\\n contentMap['sampleCategories'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'] = currentMap\\n loadMaps['CLAS.Classification.sampleCategories'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.sampleCategories'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00008'\\n currentMap['name'] = 'sampleCategories'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.sampleComponentCategory\\n currentMap = {}\\n contentMap['sampleComponentCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'] = currentMap\\n loadMaps['CLAS.Classification.sampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.sampleComponentCategory'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00004'\\n currentMap['name'] = 'sampleComponentCategory'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.targetScoreboards\\n currentMap = {}\\n contentMap['targetScoreboards'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'] = currentMap\\n loadMaps['CLAS.Classification.targetScoreboards'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.targetScoreboards'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00012'\\n currentMap['name'] = 'targetScoreboards'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n\\n # Role Classification.targetStatus\\n currentMap = {}\\n contentMap['targetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'] = currentMap\\n loadMaps['CLAS.Classification.targetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.Classification.targetStatus'\\n currentMap['type'] = 'child'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00010'\\n currentMap['name'] = 'targetStatus'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['implSkip'] = True\\n currentMap['content'] = globalMap.get('CLAS').get('abstractTypes')\\n # End of Classification\\n\\n currentMap = abstractTypes.get('Classification')\\n aList = ['createdBy', 'guid', 'isModifiable', 'lastUnlockedBy']\\n currentMap['headerAttrs'] = aList\\n aList = ['namingSystem']\\n currentMap['simpleAttrs'] = aList\\n aList = ['targetStatus', 'targetScoreboards', 'sampleComponentCategory', 'sampleCategories', 'instrumentTypes', 'holderCategorys', 'hazardPhrases', 'experimentTypes', 'access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n aList = ['experimentTypes', 'hazardPhrases', 'holderCategorys', 'instrumentTypes', 'sampleCategories', 'sampleComponentCategory', 'targetScoreboards', 'targetStatus']\\n currentMap['children'] = aList\\n\\n # Class SampleComponentCategory\\n currentMap = {}\\n abstractTypes['SampleComponentCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'] = currentMap\\n loadMaps['CLAS.SampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleComponentCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'sampleComponentCategory'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute SampleComponentCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute SampleComponentCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute SampleComponentCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role SampleComponentCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of SampleComponentCategory\\n\\n currentMap = abstractTypes.get('SampleComponentCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class ExperimentType\\n currentMap = {}\\n abstractTypes['ExperimentType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'] = currentMap\\n loadMaps['CLAS.ExperimentType'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'experimentTypes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute ExperimentType.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute ExperimentType.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute ExperimentType.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role ExperimentType.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role ExperimentType.instrumentTypes\\n currentMap = {}\\n contentMap['instrumentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'] = currentMap\\n loadMaps['CLAS.ExperimentType.instrumentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType.instrumentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00002'\\n currentMap['name'] = 'instrumentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n\\n # Role ExperimentType.sampleCategories\\n currentMap = {}\\n contentMap['sampleCategories'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'] = currentMap\\n loadMaps['CLAS.ExperimentType.sampleCategories'] = currentMap\\n currentMap['tag'] = 'CLAS.ExperimentType.sampleCategories'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00031'\\n currentMap['name'] = 'sampleCategories'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of ExperimentType\\n\\n currentMap = abstractTypes.get('ExperimentType')\\n aList = ['details', 'name', 'instrumentTypes', 'sampleCategories']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class TargetScoreboard\\n currentMap = {}\\n abstractTypes['TargetScoreboard'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'] = currentMap\\n loadMaps['CLAS.TargetScoreboard'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetScoreboard'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'targetScoreboards'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute TargetScoreboard.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute TargetScoreboard.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute TargetScoreboard.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role TargetScoreboard.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role TargetScoreboard.targetStatus\\n currentMap = {}\\n contentMap['targetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'] = currentMap\\n loadMaps['CLAS.TargetScoreboard.targetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetScoreboard.targetStatus'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00039'\\n currentMap['name'] = 'targetStatus'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of TargetScoreboard\\n\\n currentMap = abstractTypes.get('TargetScoreboard')\\n aList = ['details', 'name', 'targetStatus']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class HolderCategory\\n currentMap = {}\\n abstractTypes['HolderCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'] = currentMap\\n loadMaps['CLAS.HolderCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.HolderCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'holderCategorys'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute HolderCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute HolderCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute HolderCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role HolderCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of HolderCategory\\n\\n currentMap = abstractTypes.get('HolderCategory')\\n aList = ['details', 'name']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class HazardPhrase\\n currentMap = {}\\n abstractTypes['HazardPhrase'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'] = currentMap\\n loadMaps['CLAS.HazardPhrase'] = currentMap\\n currentMap['tag'] = 'CLAS.HazardPhrase'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'hazardPhrases'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute HazardPhrase.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute HazardPhrase.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute HazardPhrase.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Attribute HazardPhrase.phrase\\n currentMap = {}\\n contentMap['phrase'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'] = currentMap\\n loadMaps['CLAS.HazardPhrase.phrase'] = currentMap\\n currentMap['tag'] = 'CLAS.HazardPhrase.phrase'\\n currentMap['type'] = 'attr'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:28_00017'\\n currentMap['name'] = 'phrase'\\n currentMap['hicard'] = 1\\n currentMap['locard'] = 0\\n currentMap['eType'] = 'cplx'\\n currentMap['data'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00036')\\n\\n # Role HazardPhrase.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n # End of HazardPhrase\\n\\n currentMap = abstractTypes.get('HazardPhrase')\\n aList = ['details', 'name', 'phrase']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class InstrumentType\\n currentMap = {}\\n abstractTypes['InstrumentType'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'] = currentMap\\n loadMaps['CLAS.InstrumentType'] = currentMap\\n currentMap['tag'] = 'CLAS.InstrumentType'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'instrumentTypes'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute InstrumentType.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute InstrumentType.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute InstrumentType.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role InstrumentType.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role InstrumentType.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'] = currentMap\\n loadMaps['CLAS.InstrumentType.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.InstrumentType.experimentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:57_00001'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of InstrumentType\\n\\n currentMap = abstractTypes.get('InstrumentType')\\n aList = ['details', 'name', 'experimentTypes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class SampleCategory\\n currentMap = {}\\n abstractTypes['SampleCategory'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'] = currentMap\\n loadMaps['CLAS.SampleCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleCategory'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'sampleCategories'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute SampleCategory.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute SampleCategory.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute SampleCategory.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role SampleCategory.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role SampleCategory.experimentTypes\\n currentMap = {}\\n contentMap['experimentTypes'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'] = currentMap\\n loadMaps['CLAS.SampleCategory.experimentTypes'] = currentMap\\n currentMap['tag'] = 'CLAS.SampleCategory.experimentTypes'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:22:56_00030'\\n currentMap['name'] = 'experimentTypes'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of SampleCategory\\n\\n currentMap = abstractTypes.get('SampleCategory')\\n aList = ['details', 'name', 'experimentTypes']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Class TargetStatus\\n currentMap = {}\\n abstractTypes['TargetStatus'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'] = currentMap\\n loadMaps['CLAS.TargetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetStatus'\\n currentMap['type'] = 'class'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\\n currentMap['eType'] = 'cplx'\\n currentMap['fromParent'] = 'targetStatus'\\n currentMap['objkey'] = 'name'\\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\\n contentMap = {}\\n currentMap['content'] = contentMap\\n\\n # Attribute TargetStatus.applicationData\\n contentMap['applicationData'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-14-18:48:27_00007')\\n\\n # Attribute TargetStatus.details\\n contentMap['details'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:35_00001')\\n\\n # Attribute TargetStatus.name\\n contentMap['name'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-09-04-17:21:34_00014')\\n\\n # Role TargetStatus.access\\n contentMap['access'] = mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-12-31-09:03:01_00014')\\n\\n # Role TargetStatus.targetScoreboards\\n currentMap = {}\\n contentMap['targetScoreboards'] = currentMap\\n mapsByGuid['www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'] = currentMap\\n loadMaps['CLAS.TargetStatus.targetScoreboards'] = currentMap\\n currentMap['tag'] = 'CLAS.TargetStatus.targetScoreboards'\\n currentMap['type'] = 'link'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-18:23:18_00040'\\n currentMap['name'] = 'targetScoreboards'\\n currentMap['hicard'] = -1\\n currentMap['locard'] = 0\\n currentMap['copyOverride'] = True\\n # End of TargetStatus\\n\\n currentMap = abstractTypes.get('TargetStatus')\\n aList = ['details', 'name', 'targetScoreboards']\\n currentMap['simpleAttrs'] = aList\\n aList = ['access', 'applicationData']\\n currentMap['cplxAttrs'] = aList\\n\\n # Out-of-package link to Classification\\n currentMap = {}\\n exolinks['Classification'] = currentMap\\n loadMaps['CLAS.exo-Classification'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-Classification'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-09-04-17:18:54_00002'\\n currentMap['name'] = 'Classification'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.Classification\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n\\n # Out-of-package link to SampleComponentCategory\\n currentMap = {}\\n exolinks['SampleComponentCategory'] = currentMap\\n loadMaps['CLAS.exo-SampleComponentCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-SampleComponentCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00014'\\n currentMap['name'] = 'SampleComponentCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.SampleComponentCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to ExperimentType\\n currentMap = {}\\n exolinks['ExperimentType'] = currentMap\\n loadMaps['CLAS.exo-ExperimentType'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-ExperimentType'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:45_00014'\\n currentMap['name'] = 'ExperimentType'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.ExperimentType\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to TargetScoreboard\\n currentMap = {}\\n exolinks['TargetScoreboard'] = currentMap\\n loadMaps['CLAS.exo-TargetScoreboard'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-TargetScoreboard'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00040'\\n currentMap['name'] = 'TargetScoreboard'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.TargetScoreboard\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to HolderCategory\\n currentMap = {}\\n exolinks['HolderCategory'] = currentMap\\n loadMaps['CLAS.exo-HolderCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-HolderCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00049'\\n currentMap['name'] = 'HolderCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.HolderCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to HazardPhrase\\n currentMap = {}\\n exolinks['HazardPhrase'] = currentMap\\n loadMaps['CLAS.exo-HazardPhrase'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-HazardPhrase'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:52_00052'\\n currentMap['name'] = 'HazardPhrase'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.HazardPhrase\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to InstrumentType\\n currentMap = {}\\n exolinks['InstrumentType'] = currentMap\\n loadMaps['CLAS.exo-InstrumentType'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-InstrumentType'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:46_00005'\\n currentMap['name'] = 'InstrumentType'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.InstrumentType\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to SampleCategory\\n currentMap = {}\\n exolinks['SampleCategory'] = currentMap\\n loadMaps['CLAS.exo-SampleCategory'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-SampleCategory'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:44_00009'\\n currentMap['name'] = 'SampleCategory'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.SampleCategory\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\\n\\n # Out-of-package link to TargetStatus\\n currentMap = {}\\n exolinks['TargetStatus'] = currentMap\\n loadMaps['CLAS.exo-TargetStatus'] = currentMap\\n currentMap['tag'] = 'CLAS.exo-TargetStatus'\\n currentMap['type'] = 'exo'\\n currentMap['guid'] = 'www.ccpn.ac.uk_Fogh_2006-08-16-14:22:51_00039'\\n currentMap['name'] = 'TargetStatus'\\n currentMap['eType'] = 'cplx'\\n currentMap['class'] = ccp.api.lims.Classification.TargetStatus\\n aList = list()\\n currentMap['keyMaps'] = aList\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2008-06-30-16:30:50_00001'))\\n aList.append(mapsByGuid.get('www.ccpn.ac.uk_Fogh_2006-08-16-14:22:53_00033'))\",\n \"def get_map(self):\\n return self.parent.controller.get_map()\",\n \"def get_map_values(self, lons, lats, ibin=None):\\n raise NotImplementedError(\\\"MapBase.get_map_values()\\\")\",\n \"def melInfo(*args, **kwargs)->List[AnyStr]:\\n pass\",\n \"def manage_getPermissionMapping(self):\\n wrapper = getattr(self, '_permissionMapper', None)\\n if wrapper is None:\\n wrapper = PM()\\n\\n perms = {}\\n for p in self.possible_permissions():\\n perms[getPermissionIdentifier(p)] = p\\n\\n r = []\\n a = r.append\\n for ac_perms in self.ac_inherited_permissions(1):\\n p = perms.get(getPermissionMapping(ac_perms[0], wrapper), '')\\n a({'permission_name': ac_perms[0], 'class_permission': p})\\n return r\",\n \"def map2(f, A, B):\\n return tuple(map(lambda ra, rb: tuple(map(f, ra, rb)),\\n A, B))\",\n \"def map_callback(self,msg):\\n self.map = np.array(msg.data).reshape((msg.info.height, msg.info.width))\\n self.map_info = msg.info\",\n \"def _mapping(self):\\n return [('auth.check', self.notify)]\",\n \"def view(self) -> 'typing.Mapping[int, Dataclass]':\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73169774","0.66956455","0.64216447","0.62629515","0.62388194","0.61226577","0.60859364","0.60153437","0.5962893","0.5897065","0.5868335","0.58180994","0.5802025","0.57440436","0.57440436","0.5740578","0.5721933","0.5717749","0.57169694","0.5674728","0.56681097","0.5656093","0.5628132","0.5596187","0.55658823","0.5559668","0.55110925","0.5506512","0.54828626","0.54779285","0.5459683","0.54513186","0.54379123","0.54369134","0.5419847","0.54168653","0.54101014","0.53915024","0.53491396","0.5346178","0.5337239","0.5318052","0.52985036","0.5296111","0.52800936","0.52651525","0.52562153","0.5250311","0.5249576","0.5242957","0.523992","0.5236059","0.5234669","0.52332854","0.5202732","0.51956904","0.51830024","0.5181458","0.5172331","0.516553","0.5159931","0.5159786","0.5145165","0.5142126","0.5140815","0.5139053","0.5121078","0.5119642","0.5111277","0.51105416","0.51000285","0.50995725","0.5096801","0.5093919","0.5089376","0.5087809","0.50812316","0.50698626","0.50695354","0.506742","0.5063107","0.5062344","0.5061961","0.5060879","0.5058873","0.50588334","0.5055417","0.50554025","0.50530106","0.5034605","0.50326186","0.5030804","0.5029369","0.5024098","0.50229514","0.50195104","0.5013226","0.5007956","0.5006174","0.5005882"],"string":"[\n \"0.73169774\",\n \"0.66956455\",\n \"0.64216447\",\n \"0.62629515\",\n \"0.62388194\",\n \"0.61226577\",\n \"0.60859364\",\n \"0.60153437\",\n \"0.5962893\",\n \"0.5897065\",\n \"0.5868335\",\n \"0.58180994\",\n \"0.5802025\",\n \"0.57440436\",\n \"0.57440436\",\n \"0.5740578\",\n \"0.5721933\",\n \"0.5717749\",\n \"0.57169694\",\n \"0.5674728\",\n \"0.56681097\",\n \"0.5656093\",\n \"0.5628132\",\n \"0.5596187\",\n \"0.55658823\",\n \"0.5559668\",\n \"0.55110925\",\n \"0.5506512\",\n \"0.54828626\",\n \"0.54779285\",\n \"0.5459683\",\n \"0.54513186\",\n \"0.54379123\",\n \"0.54369134\",\n \"0.5419847\",\n \"0.54168653\",\n \"0.54101014\",\n \"0.53915024\",\n \"0.53491396\",\n \"0.5346178\",\n \"0.5337239\",\n \"0.5318052\",\n \"0.52985036\",\n \"0.5296111\",\n \"0.52800936\",\n \"0.52651525\",\n \"0.52562153\",\n \"0.5250311\",\n \"0.5249576\",\n \"0.5242957\",\n \"0.523992\",\n \"0.5236059\",\n \"0.5234669\",\n \"0.52332854\",\n \"0.5202732\",\n \"0.51956904\",\n \"0.51830024\",\n \"0.5181458\",\n \"0.5172331\",\n \"0.516553\",\n \"0.5159931\",\n \"0.5159786\",\n \"0.5145165\",\n \"0.5142126\",\n \"0.5140815\",\n \"0.5139053\",\n \"0.5121078\",\n \"0.5119642\",\n \"0.5111277\",\n \"0.51105416\",\n \"0.51000285\",\n \"0.50995725\",\n \"0.5096801\",\n \"0.5093919\",\n \"0.5089376\",\n \"0.5087809\",\n \"0.50812316\",\n \"0.50698626\",\n \"0.50695354\",\n \"0.506742\",\n \"0.5063107\",\n \"0.5062344\",\n \"0.5061961\",\n \"0.5060879\",\n \"0.5058873\",\n \"0.50588334\",\n \"0.5055417\",\n \"0.50554025\",\n \"0.50530106\",\n \"0.5034605\",\n \"0.50326186\",\n \"0.5030804\",\n \"0.5029369\",\n \"0.5024098\",\n \"0.50229514\",\n \"0.50195104\",\n \"0.5013226\",\n \"0.5007956\",\n \"0.5006174\",\n \"0.5005882\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5570534"},"document_rank":{"kind":"string","value":"24"}}},{"rowIdx":20183,"cells":{"query":{"kind":"string","value":"Defines the way to parse the magic command ``%%maml``."},"document":{"kind":"string","value":"def maml_parser():\n parser = MagicCommandParser(prog=\"maml\",\n description='Runs a maml script.')\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\n help='hide output')\n return parser"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def maml(self, line, cell):\n parser = self.get_parser(CsMLMagics.maml_parser, \"maml\")\n args = self.get_args(line, parser)\n\n if args is not None:\n quiet = args.quiet\n out, err = maml(cell, not quiet)\n if out:\n print(out)\n if err:\n print('-----')\n print(err)","def mlnet_parser():\n parser = MagicCommandParser(prog=\"mlnet\",\n description='Compiles and wrap a C# function into a Python function.\\n'\n 'Automatically adds ML.net dependencies.')\n parser.add_argument('name', type=str, help='function name')\n parser.add_argument('-i', '--idep', nargs='*', action='append',\n help='internal dependencies (like System, System.Linq)')\n parser.add_argument('-d', '--dep', nargs='*', action='append',\n help='dependencies (assembly name without extension)')\n parser.add_argument('-c', '--catch', action='store', default=False,\n help='catch exception')\n return parser","async def man(self, ctx: Context, *, command: str) -> None:\n base_query = f\"https://www.mankier.com/api/v2/mans/?q={command}\"\n query_url = urllib.parse.quote_plus(base_query, safe=\";/?:@&=$,><-[]\")\n\n async with ctx.typing():\n # Get API query responses\n async with self.session.get(query_url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n results = json.loads(await response.text())[\"results\"]\n\n # Use first result\n if len(results) > 0:\n result = results[0]\n else:\n await ctx.send(\"Invalid query, no such command\")\n return\n\n base_url = f\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\"\n url = urllib.parse.quote_plus(base_url, safe=\";/?:@&=$,><-[]\")\n\n # Load man page from first result\n async with self.session.get(url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n result = json.loads(await response.text())\n\n embed = Embed(\n title=f\"Man page of: **{result['name'].capitalize()}**\",\n url=result[\"url\"],\n description=f\"**{result['description']}** ({result['section']})\"\n )\n\n for anchor in result['anchors']:\n embed.add_field(\n name=f\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\",\n value=f\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\n[Link here]({anchor['url']})\",\n inline=False\n )\n # TODO: Solve this with pagination\n try:\n await ctx.send(embed=embed)\n except HTTPException as e:\n if e.code == 50035:\n await ctx.send(embed=Embed(\n description=\"Body is too long to show\",\n color=Color.red()\n ))\n else:\n raise e","def handle_magic(self, line, continue_prompt=None,\n pre=None,iFun=None,theRest=None):\n\n cmd = '%sipmagic(\"%s\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\n self.log(cmd,continue_prompt)\n self.update_cache(line)\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\n return cmd","def magic_lsmagic(self, parameter_s = ''):\n print 'Available magic functions:\\n@'+' @'.join(self.lsmagic())\n print '\\n' + Magic.auto_status[self.rc.automagic]\n return None","def _from_command_line():\n # Manim can be called from the command line in three different\n # ways. The first two involve using the manim or manimcm commands\n prog = os.path.split(sys.argv[0])[-1]\n from_cli_command = prog in [\"manim\", \"manimcm\"]\n\n # The third way involves using `python -m manim ...`. In this\n # case, the CLI arguments passed to manim do not include 'manim',\n # 'manimcm', or even 'python'. However, the -m flag will always\n # be the first argument.\n from_python_m = sys.argv[0] == \"-m\"\n\n return from_cli_command or from_python_m","def parse(self, args):\r\n # handle `sl ...`\r\n main_args = self.parse_main_args(args)\r\n module_name = main_args['<module>']\r\n\r\n # handle `sl <module> ...`\r\n module_args = self.parse_module_args(module_name, main_args['<args>'])\r\n\r\n # get the command argument\r\n command_name = module_args.get('<command>')\r\n\r\n # handle `sl <module> <command> ...`\r\n return self.parse_command_args(\r\n module_name,\r\n command_name,\r\n main_args['<args>'])","def magic2python(cmd):\n\n if cmd.startswith('#@') or cmd.startswith('@'):\n if cmd[0]=='#':\n cmd = cmd[1:]\n # we need to return the proper line end later\n if cmd[-1] == '\\n':\n endl = '\\n'\n else:\n endl = ''\n try:\n func,args = cmd[1:].split(' ',1)\n except:\n func,args = cmd[1:].rstrip(),''\n args = args.replace('\"','\\\\\"').replace(\"'\",\"\\\\'\").rstrip()\n return '__IP.magic_%s (\"%s\")%s' % (func,args,endl)\n else:\n return cmd","def magic_magic(self, parameter_s = ''):\n\n mode = ''\n try:\n if parameter_s.split()[0] == '-latex':\n mode = 'latex'\n except:\n pass\n\n magic_docs = []\n for fname in self.lsmagic():\n mname = 'magic_' + fname\n for space in (Magic,self,self.__class__):\n try:\n fn = space.__dict__[mname]\n except KeyError:\n pass\n else:\n break\n magic_docs.append('@%s:\\n\\t%s\\n' %(fname,fn.__doc__))\n magic_docs = ''.join(magic_docs)\n\n if mode == 'latex':\n print self.format_latex(magic_docs)\n return\n else:\n magic_docs = self.format_screen(magic_docs)\n \n outmsg = \"\"\"\nIPython's 'magic' functions\n===========================\n\nThe magic function system provides a series of functions which allow you to\ncontrol the behavior of IPython itself, plus a lot of system-type\nfeatures. All these functions are prefixed with a @ character, but parameters\nare given without parentheses or quotes.\n\nExample: typing '@cd mydir' (without the quotes) changes you working directory\nto 'mydir', if it exists.\n\nIf you have 'automagic' enabled (via the command line option or with the\n@automagic function), you don't need to type in the @ explicitly.\n\nYou can define your own magic functions to extend the system. See the supplied\nipythonrc and example-magic.py files for details (in your ipython\nconfiguration directory, typically $HOME/.ipython/).\n\nYou can also define your own aliased names for magic functions. In your\nipythonrc file, placing a line like:\n\n execute __IP.magic_cl = __IP.magic_clear\n\nwill define @cl as a new name for @clear.\n\nFor a list of the available magic functions, use @lsmagic. For a description\nof any of them, type @magic_name?.\n\nCurrently the magic system has the following functions:\\n\"\"\"\n\n outmsg = (\"%s\\n%s\\n\\nSummary of magic functions (from @lsmagic):\"\n \"\\n\\n@%s\\n\\n%s\" % (outmsg,\n magic_docs,\n ' @'.join(self.lsmagic()),\n Magic.auto_status[self.rc.automagic] ) )\n\n page(outmsg,screen_lines=self.rc.screen_length)","def magic_ll(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^l')","def _parse_ml(self, line):\n # Parse the line\n fields = line.split('\\\\')\n if self.lang == ENGLISH:\n # pylint: disable=C0301\n # English sample:\n # 14\\abandonment\\94\\C\\\\1\\N\\N\\N\\N\\Y\\abandon+ment\\2x\\SA\\N\\N\\N\\#\\N\\N\\SA\\((abandon)[V],(ment)[N|V.])[N]\\N\\N\\N\n # From the README:\n # The eml.cd file contains the following fields:\n # 1. IdNum\n # 2. Head\n # 3. Cob\n # 4. MorphStatus\n # 5. Lang\n # 6. MorphCnt\n # 7. NVAffComp\n # 8. Der\n # 9. Comp\n # 10. DerComp\n # 11. Def\n # 12. Imm\n # 13. ImmSubCat\n # 14. ImmSA\n # 15. ImmAllo\n # 16. ImmSubst\n # 17. ImmOpac\n # 18. TransDer\n # 19. ImmInfix\n # 20. ImmRevers\n # 21 FlatSA\n # 22. StrucLab\n # 23. StrucAllo\n # 24. StrucSubst\n # 25. StrucOpac\n lemma = fields[0]\n word = fields[1]\n derivation = fields[21]\n elif self.lang == DUTCH:\n # pylint: disable=C0301\n # Dutch sample:\n # 19\\aalbessengelei\\7\\C\\1\\Y\\Y\\Y\\aalbes+en+gelei\\NxN\\N\\N\\(((aal)[N],(bes)[N])[N],(en)[N|N.N],(gelei)[N])[N]\\N\\N\\N\n # The dml.cd file contains the following fields:\n # 1. IdNum\n # 2. Head\n # 3. Inl\n # 4. MorphStatus\n # 5. MorphCnt\n # 6. DerComp\n # 7. Comp\n # 8. Def\n # 9. Imm\n # 10. ImmSubCat\n # 11. ImmAllo\n # 12. ImmSubst\n # 13. StrucLab\n # 14. StruAcAllo\n # 15. StrucSubst\n # 16. Sepa\n lemma = fields[0]\n word = fields[1]\n derivation = fields[12]\n\n # Skip multi-word entries for roots\n roots = self._get_root(derivation) if \" \" not in word else None\n return (lemma, word, roots)","def getArbitraryManInput(self):\n return \"\"\".TH MANHOLE \"1\" \"August 2001\" \"\" \"\"\n.SH NAME\nmanhole \\- Connect to a Twisted Manhole service\n.SH SYNOPSIS\n.B manhole\n.SH DESCRIPTION\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\ncode as if at an interactive Python console inside a running Twisted process\nwith this.\"\"\"","def maml(self, maml: List[PredictionsDatapoints]):\n\n self._maml = maml","def niw_mmml_mp(args):\n return niw_mmml(*args)","def man(command):\n\tspeech.speak(\"Executing 'man \" + command + \"' to show you documentation for this command.\")\n\tsubprocess.call([\"man\", command])","def command(self,cmd):\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))","def magic(self, parameter_s=''):\n\n mode = ''\n try:\n mode = parameter_s.split()[0][1:]\n except IndexError:\n pass\n\n brief = (mode == 'brief')\n rest = (mode == 'rest')\n magic_docs = self._magic_docs(brief, rest)\n\n if mode == 'latex':\n print(self.format_latex(magic_docs))\n return\n else:\n magic_docs = format_screen(magic_docs)\n\n out = [\"\"\"\nIPython's 'magic' functions\n===========================\n\nThe magic function system provides a series of functions which allow you to\ncontrol the behavior of IPython itself, plus a lot of system-type\nfeatures. There are two kinds of magics, line-oriented and cell-oriented.\n\nLine magics are prefixed with the % character and work much like OS\ncommand-line calls: they get as an argument the rest of the line, where\narguments are passed without parentheses or quotes. For example, this will\ntime the given statement::\n\n %timeit range(1000)\n\nCell magics are prefixed with a double %%, and they are functions that get as\nan argument not only the rest of the line, but also the lines below it in a\nseparate argument. These magics are called with two arguments: the rest of the\ncall line and the body of the cell, consisting of the lines below the first.\nFor example::\n\n %%timeit x = numpy.random.randn((100, 100))\n numpy.linalg.svd(x)\n\nwill time the execution of the numpy svd routine, running the assignment of x\nas part of the setup phase, which is not timed.\n\nIn a line-oriented client (the terminal or Qt console IPython), starting a new\ninput with %% will automatically enter cell mode, and IPython will continue\nreading input until a blank line is given. In the notebook, simply type the\nwhole cell as one entity, but keep in mind that the %% escape can only be at\nthe very start of the cell.\n\nNOTE: If you have 'automagic' enabled (via the command line option or with the\n%automagic function), you don't need to type in the % explicitly for line\nmagics; cell magics always require an explicit '%%' escape. By default,\nIPython ships with automagic on, so you should only rarely need the % escape.\n\nExample: typing '%cd mydir' (without the quotes) changes your working directory\nto 'mydir', if it exists.\n\nFor a list of the available magic functions, use %lsmagic. For a description\nof any of them, type %magic_name?, e.g. '%cd?'.\n\nCurrently the magic system has the following functions:\"\"\",\n magic_docs,\n \"Summary of magic functions (from %slsmagic):\" % magic_escapes['line'],\n str(self.lsmagic()),\n ]\n page.page('\\n'.join(out))","def parseargs(p):\n p.set_defaults(func=func)\n p.description = \"Print machine architecture.\"\n return p","def yamlmain(argv=None):\n if argv is None:\n argv = sys.argv\n if len(argv) == 1:\n _fullusage()\n try:\n command = argv[1]\n if command in ['get', 'dump']:\n _rosparam_cmd_get_dump(command, argv)\n elif command in ['set', 'load']:\n _rosparam_cmd_set_load(command, argv)\n elif command in ['delete']:\n _rosparam_cmd_delete(argv)\n elif command == 'list':\n _rosparam_cmd_list(argv)\n else:\n _fullusage()\n except RosParamException as e:\n print(\"ERROR: \"+str(e), file=sys.stderr)\n sys.exit(1)","def arg_parse():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-m\", \"--mix\", required=False, help=\"cube shuffle\")\n parser.add_argument(\"-e\", \"--explain\", action=\"store_true\", help=\"Get more explanation about steps\")\n options = parser.parse_args()\n return options","def _llm_type(self) -> str:\n return \"llama.cpp\"","def get_ymal_load(yamlfile):\n with open(yamlfile, 'r', encoding='utf-8') as fr:\n filedata = fr.read()\n yamldata = yaml.full_load(filedata)\n return yamldata","def _parse_args(self, cmd_line_list):\n parser = ArgumentParser()\n parser.add_argument('--yaml', help='yaml file specifying config to run')\n args = parser.parse_args(cmd_line_list)\n return vars(args)","def _compat_parse_magic(self):\n def warning(magic, option):\n LOG.warning(\"Deprecated \\\"magic\\\" option \\\"{m}\\\" found. Please use new-style option \\\"{o}\\\" instead (see user manual).\".format(m=magic, o=option))\n\n magic_auto_backports = re.search(r\"\\*\\s*MINI_BUILDD:\\s*AUTO_BACKPORTS:\\s*([^*.\\[\\]]+)\", self._top_changes)\n if magic_auto_backports:\n warning(\"AUTO_BACKPORTS\", \"auto-ports\")\n self._set(\"auto-ports\", magic_auto_backports.group(1))\n\n magic_backport_mode = re.search(r\"\\*\\s*MINI_BUILDD:\\s*BACKPORT_MODE\", self._top_changes)\n if magic_backport_mode:\n warning(\"BACKPORT_MODE\", \"ignore-lintian\")\n self._set(\"ignore-lintian\", \"true\")","def yamllint(context):\n exec_cmd = \"yamllint .\"\n run_cmd(context, exec_cmd)","def parsed(self, raw):\n if isinstance(raw, ParsedString):\n p = raw\n else:\n # preparse is an overridable hook; default makes no changes\n s = self.preparse(raw)\n s = self.input_source_parser.transformString(s.lstrip())\n s = self.commentGrammars.transformString(s)\n for (shortcut, expansion) in self.shortcuts:\n if s.lower().startswith(shortcut):\n s = s.replace(shortcut, expansion + ' ', 1)\n break\n try:\n result = self.main_parser.parseString(s)\n except pyparsing.ParseException:\n # If we have a parsing failure, treat it is an empty command and move to next prompt\n result = self.main_parser.parseString('')\n result['raw'] = raw\n result['command'] = result.multilineCommand or result.command\n result = self.postparse(result)\n p = ParsedString(result.args)\n p.parsed = result\n p.parser = self.parsed\n return p","def configure_parser_motif(subparsers):\n help_msg = \"Motif set (PFMs/PWMs) commands.\"\n desc_msg = help_msg + dedent(\"\"\"\n \n MotifScan only detects the binding sites of known motifs. Before scanning, \n the motif set should be installed and built with PFMs (Position Frequency \n Matrices). Since different assemblies have different genome contents, it \n is necessary to build the PFMs and get proper motif score cutoffs for every \n genome assembly you want to scan later. \n \"\"\")\n\n epilog_msg = dedent(\"\"\"\n Examples:\n --------- \n 1) Display installed motif sets:\n \n motifscan motif --list\n \n 2) Display all available motif sets in a remote database:\n \n motifscan motif --list-remote\n \n 3) Install a motif set from a remote database and build for genome 'hg19':\n \n motifscan motif --install -n <motif_set> -r <remote_PFMs> -g hg19\n \n 4） Install a motif set with local PFMs file(s) and build for genome 'mm9':\n\n motifscan motif --install -n <motif_set> -i <pfms.jaspar> -g mm9\n \n 5) Build an installed motif set (PFMs) for additional assembly 'hg38':\n \n motifscan motif --build <motif_set> -g hg38\n \n 6) Uninstall a motif set:\n \n motifscan motif --uninstall <motif_set>\n \n Notes:\n ------\n 1) When installing a motif set by `--install`, you can append a `-g` option \n to build the PFMs for the specified assembly after installation.\n \n 2) The genome assembly specified by `-g` should be pre-installed by command \n `motifscan genome --install`.\n \n 3) The path of newly installed motif set will be automatically saved and \n all the built PWMs files are stored under the directory. If you move it \n to a new path, please reconfigure it:\n \n motifscan config --set-motif <motif_set> <new_path>\n \"\"\")\n\n parser = subparsers.add_parser(\n \"motif\", description=desc_msg, help=help_msg, epilog=epilog_msg,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n subcommands = parser.add_argument_group(\"Motif Subcommands\")\n subcommands = subcommands.add_mutually_exclusive_group()\n subcommands.add_argument(\n \"--list\", dest=\"list\", action=\"store_true\", default=False,\n help=\"Display installed motif sets.\")\n subcommands.add_argument(\n \"--list-remote\", dest=\"list_remote\", action=\"store_true\",\n default=False, help=\"Display available remote motif sets.\")\n subcommands.add_argument(\n \"--install\", dest=\"install\", action=\"store_true\", default=False,\n help=\"Install a new motif set with PFMs.\")\n subcommands.add_argument(\n \"--build\", metavar=\"NAME\", dest=\"build\", default=None,\n help=\"Build an installed motif set for additional genome assembly.\")\n subcommands.add_argument(\n \"--uninstall\", metavar=\"NAME\", dest=\"uninstall\",\n help=\"Uninstall a motif set.\")\n subcommands.required = True\n\n parser_install = parser.add_argument_group(\"Install Options\")\n parser_install.add_argument(\n \"-n\", \"--name\", metavar=\"NAME\", dest=\"name\",\n help=\"Name of the motif set (PFMs) to be installed.\")\n parser_install.add_argument(\n \"-i\", metavar=\"FILE\", dest=\"pfm_files\", nargs=\"+\",\n help=\"Local motif PFMs file(s) to be installed.\")\n parser_install.add_argument(\n \"-r\", \"--remote\", metavar=\"PFMs\", dest=\"remote\",\n help=\"Download a remote motif PFMs set.\")\n parser_install.add_argument(\n \"-o\", \"--output-dir\", metavar=\"DIR\", dest=\"output_dir\",\n help=\"Write to a given directory instead of the default directory.\")\n\n parser_remote = parser.add_argument_group(\"Remote Database Options\")\n parser_remote.add_argument(\n \"--database\", dest=\"database\",\n choices=[\"jaspar_core\", \"jaspar_collections\"], default=\"jaspar_core\",\n help=\"Which remote database is used to list/install motif set (PFMs). \"\n \"Default: jaspar_core\")\n\n parser_build = parser.add_argument_group(\"Build Options\")\n parser_build.add_argument(\n \"-g\", \"--genome\", metavar=\"GENOME\", dest=\"genome\",\n help=\"Genome assembly to build the motif set (PFMs) for.\")\n parser_build.add_argument(\n \"--n-random\", metavar=\"N\", dest=\"n_random\", type=int, default=1000000,\n help=\"Generate N random background sequences to calculate motif score \"\n \"cutoffs. Default: 1,000,000\")\n parser_build.add_argument(\n \"--n-repeat\", metavar=\"N\", dest=\"n_repeat\", type=_pos_int, default=1,\n help=\"Repeat N rounds of random sampling and use the averaged cutoff \"\n \"as final cutoff. Default: 1\")\n parser_build.add_argument(\n \"--max-n\", metavar=\"N\", dest=\"max_n\", type=int, default=0,\n help=\"The maximal number of `N` base allowed in each random sampled \"\n \"sequence. Default: 0\")\n parser_build.add_argument(\n \"--seed\", metavar=\"SEED\", dest=\"seed\", type=int, default=None,\n help=\"Random seed used to generate background sequences.\")\n\n parser_threads = parser.add_argument_group(\"Threads Options\")\n parser_threads.add_argument(\n \"-t\", \"--threads\", metavar=\"N\", dest=\"n_threads\", type=int, default=1,\n help=\"Number of processes used to run in parallel.\")\n\n parser = _add_verbose_argument(parser)\n parser.set_defaults(func=motif.run)","def readMaf( options, data ):\n regex = 's\\s+([\\w\\d\\-]+?)\\.([\\w\\d\\.\\+\\-]+?)\\s+(\\d+)\\s+(\\d+)\\s+([-+])\\s+(\\d+)\\s+([\\-actgurykmswbdhvnACTGURYKMSWBDHVN]+)'\n pat = re.compile( regex )\n mf = open( options.maf )\n mafLineList = []\n order = -1\n hplList = []\n hpl = ''\n five = ''\n three = ''\n for line in mf:\n if line.startswith('#HPL'):\n d = line.split(' ')\n # example line: \"#HPL=12049 5=1 3=1 SPL=123412 S5=0 S3=12\"\n # there will be one hpl line per options.other line\n # in blocks that contain the options.ref\n hpl = int( d[0][5:] ) # comment at start of this field\n hFive = int( d[1][2] )\n hThree = int( d[2][2] )\n spl = int( d[3][4:] ) # no comment at start of this field\n hplList.append( { 'hpl': hpl, 'hFive': hFive, \n 'hThree': hThree, 'spl': spl } )\n continue\n if line.startswith('s'):\n line = line.strip()\n ml, order = extractMafLine( line, order, pat, options, data )\n if ml is None:\n sys.stderr.write( 'regexp fail on file %s line: \\'%s\\'\\n'\n 'Regex: \\'%s\\'\\n' % ( options.maf, line, regex ) )\n sys.exit( 1 )\n if ml == 'notOurGenome':\n continue\n if ml.length != len( ml.sequence ):\n sys.stderr.write( 'Error while working on file %s :\\n '\n 'printed sequence length (%d) not equal to actual sequence '\n 'length (%d) ref genome:%s other genome:%s line below:\\n%s\\n' % \n ( options.maf, ml.length, len( ml.sequence ), options.ref, options.other, line ) )\n sys.exit( 1 )\n mafLineList.append( ml )\n else:\n # end of the block\n if len( mafLineList ) > 0:\n extractBlockPairs( mafLineList, hplList, options, data )\n mafLineList = []\n order = -1\n hplList = []\n hpl = ''\n five = ''\n three = ''\n if len( mafLineList ) > 0:\n extractBlockPairs( mafLineList, hplList, options, data )","def set_m(self, varname: str, varval: Optional[str]) -> None:\n if varname:\n self.pandoc.append('-M')\n self.pandoc.append(f'{varname}={varval}')","def run_man(self, expanded, unexpanded) : \n\t\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\n\t\tif not unexpanded :\n\t\t\tunexpanded = methodslist\n\t\tunexpanded.sort()\n\n\t\tresults = []\n\t\tfor method in unexpanded :\n\t\t\tif results :\n\t\t\t\t# more than one command to display help for\n\t\t\t\t# so we separate them in the plain text output\n\t\t\t\tself.printf(\"\\n--------\\n\\n\")\n\t\t\tif not hasattr(self, 'run_' + method) :\n\t\t\t\thelp = helphtml = \"Invalid command\"\n\t\t\telse :\n\t\t\t\thelp = getattr(self, 'run_' + method).__doc__\n\t\t\t\tif not help :\n\t\t\t\t\thelp = helphtml = \"Undocumented command\"\n\t\t\t\telse :\n\t\t\t\t\thelplines = map(string.strip, string.split(help, '\\n'))\n\t\t\t\t\thelp = string.join(helplines, '\\n')\n\t\t\t\t\thelphtml = string.join(helplines, '<br />')\n\t\t\tcommand = '<a href=\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\n\t\t\tresults.append({\"Command\": command, \"Help\": helphtml})\n\t\t\tself.printf(\"%s: %s\\n\" % (method, help))\n\t\tself.tableDisplay(\"man\", [\"Command\", \"Help\"], results)","def _parse_args(marbl_root):\n\n import argparse\n import os\n\n parser = argparse.ArgumentParser(description=\"Convert MARBL's YAML files to JSON\",\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n\n parser.add_argument('-s', '--settings_file', action='store', dest='settings_file',\n default=os.path.join(marbl_root, 'src', 'default_settings.yaml'),\n help='Location of YAML-formatted MARBL settings file to convert to JSON')\n\n parser.add_argument('-d', '--diags_file', action='store', dest='diags_file',\n default=os.path.join(marbl_root, 'src', 'default_diagnostics.yaml'),\n help='Location of YAML-formatted MARBL diagnostics file to convert to JSON')\n\n parser.add_argument('-o', '--output_dir', action='store', dest='output_dir',\n default=os.path.join(marbl_root, 'autogenerated_src'),\n help=\"Directory where JSON file(s) will be created\")\n\n return parser.parse_args()","def main(raw_args):\n parser = argparse.ArgumentParser()\n parser.add_argument('--module-link')\n parser.add_argument('module_path', type=os.path.realpath)\n args = parser.parse_args(raw_args)\n\n return md_module(\n load_module_from_path(args.module_path), module_link=args.module_link)","def Parse(self, attribute_to_args_map, base_fallthroughs_map,\n parsed_args=None, plural=False, allow_empty=False):\n raise NotImplementedError","def magic_ld(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep /$')","def mfa_cli(ctx: click.Context) -> None:\n from montreal_forced_aligner.command_line.utils import check_server, start_server, stop_server\n\n config.load_configuration()\n auto_server = False\n run_check = True\n if ctx.invoked_subcommand == \"anchor\":\n config.CLEAN = False\n config.USE_POSTGRES = True\n config.CLEAN = False\n config.USE_POSTGRES = True\n if \"--help\" in sys.argv or ctx.invoked_subcommand in [\n \"configure\",\n \"version\",\n \"history\",\n \"server\",\n \"align_one\",\n ]:\n auto_server = False\n run_check = False\n elif ctx.invoked_subcommand in [\"model\", \"models\"]:\n if \"add_words\" in sys.argv or \"inspect\" in sys.argv:\n config.CLEAN = True\n config.USE_POSTGRES = False\n else:\n run_check = False\n elif ctx.invoked_subcommand == \"g2p\":\n if len(sys.argv) > 2 and sys.argv[2] == \"-\":\n run_check = False\n auto_server = False\n else:\n auto_server = config.AUTO_SERVER\n if \"--no_use_postgres\" in sys.argv or not config.USE_POSTGRES:\n run_check = False\n auto_server = False\n if auto_server:\n start_server()\n elif run_check:\n check_server()\n warnings.simplefilter(\"ignore\")\n check_third_party()\n if ctx.invoked_subcommand != \"anchor\":\n hooks = ExitHooks()\n hooks.hook()\n atexit.register(hooks.history_save_handler)\n if auto_server:\n atexit.register(stop_server)","async def manga(self, ctx: commands.Context) -> None:\n if ctx.invoked_subcommand is None:\n if ctx.subcommand_passed is None:\n # There is no subcommand: inform the user about the manga reader.\n summary = \"\"\"Hi! Welcome to Bakerbot's manga reader.\n This cog houses commands for searching and reading manga.\n See `$help mangadex` for a full list of available subcommands.\"\"\"\n\n embed = utilities.Embeds.standard()\n embed.set_footer(text=\"Powered by the Mangadex API.\", icon_url=utilities.Icons.info)\n embed.description = summary\n await ctx.reply(embed=embed)\n else:\n # The subcommand was not valid: throw a fit.\n command = f\"${ctx.command.name} {ctx.subcommand_passed}\"\n summary = f\"`{command}` is not a valid command.\"\n footer = \"Try $help mangadex for a full list of available subcommands.\"\n embed = utilities.Embeds.status(False, summary)\n embed.set_footer(text=footer, icon_url=utilities.Icons.cross)\n await ctx.reply(embed=embed)","def parsingcommands(self):\n parser = argparse.ArgumentParser(\n description=\"httpfs is a simple file server.\")\n parser.add_argument(\"-v\", action=\"store_true\", dest=\"debug\",\n help=\"Prints debugging messages.\", default=False)\n parser.add_argument(\"-p\", action=\"store\", dest=\"port\",\n help=\"Specifies the port number that the server will listen and serve at. Default is 8080.\",\n type=int, default=8080)\n parser.add_argument(\"-d\", action=\"store\", dest=\"path_to_dir\",\n help=\"Specifies the directory that the server will use to read/writerequested files. \\\n Default is the current directory when launching theapplication.\",\n default='./')\n parser.add_argument(\"-arq\", action='store_true', dest=\"arq\", default=False, help=\"Automatic-Repeat-Request (ARQ)\")\n\n return parser.parse_args()","def command(self, cmd):\n self.lmp.command(cmd)","def parse_cmd(cmd):\n begin_pat = re.compile(r'BEGIN\\s*\\{(.+?)\\}\\s*;?', re.X | re.S)\n end_pat = re.compile(r'END\\s*\\{(.+?)\\}\\s*;?', re.X | re.S)\n normal_pat = re.compile(r'([^{]*)(\\{(.+?)\\})?\\s*;?', re.X | re.S)\n\n # get BEGIN part\n begin = u''\n m = begin_pat.search(cmd)\n if m:\n begin = m.group(1).strip()\n cmd = cmd.replace(m.group(0), u'')\n\n # get END part\n end = u''\n m = end_pat.search(cmd)\n if m:\n end = m.group(1).strip()\n cmd = cmd.replace(m.group(0), u'')\n\n # get NORMAL part\n normal = (u'', u'')\n m = normal_pat.search(cmd)\n if m:\n pattern = m.group(1) or u'' # get u'' if \\1 is None\n action = m.group(3) or u'' # get u'' if \\3 is None\n normal = (pattern.strip(), action.strip())\n\n return (begin, normal, end)","def __getattr__(self, item):\n if item not in _CommandsMetaClass.commands_dict:\n raise MPDCommandNotExists(\"no such command: '{}'\".format(item))\n\n f = lambda *args: \"{} {}\\n\".format(item, ' '.join(_CommandsMetaClass._quote_arguments(args)))\n f.__doc__ = \"Command's Arguments: {}\".format(_CommandsMetaClass.commands_dict[item])\n f.__name__ = item\n return f","def get_cmd():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", action=\"store\", dest=\"inputfile\", help=\"file with multiple hmm models\")\n parser.add_argument(\"-o\", action=\"store\", dest=\"dirout\", help=\"directory to store separated hmm models\")\n params = parser.parse_args()\n return params","def configure_parser_main():\n description = dedent(\"\"\"\n MotifScan: A motif discovery tool to detect the occurrences of known motifs\n \n Given a set of input genomic regions, MotifScan scans the sequences to \n detect the occurrences of known motifs. It can also perform an enrichment \n analysis to check whether these motifs are over/under-represented compared \n to the control regions.\n \n !!! NOTE !!!\n MotifScan requires basic data files including genome sequences and motif \n PFMs (Position Frequency Matrices) to detect the binding sites of motifs. \n Before scanning, users should install genome assemblies and motif sets from\n a remote database or with local prepared files via `motifscan genome` and \n `motifscan motif` subcommands.\n \n Citation:\n Sun, H., Wang, J., Gong, Z. et al. Quantitative integration of epigenomic \n variation and transcription factor binding using MAmotif toolkit identifies\n an important role of IRF2 as transcription activator at gene promoters. \n Cell Discov 4, 38 (2018). https://doi.org/10.1038/s41421-018-0045-y\n \"\"\")\n\n epilog_msg = dedent(\"\"\"\n Please run `motifscan COMMAND -h` to see the subcommand options.\n \n See also: \n Documentation: https://motifscan.readthedocs.io\n Source code: https://github.com/shao-lab/MotifScan\n Bug reports: https://github.com/shao-lab/MotifScan/issues\n \"\"\")\n\n parser = argparse.ArgumentParser(\n description=description, epilog=epilog_msg,\n formatter_class=argparse.RawDescriptionHelpFormatter)\n parser.add_argument(\"-v\", \"--version\", action=\"version\",\n version=f\"MotifScan {__version__}\")\n\n subparsers = parser.add_subparsers(title=\"MotifScan Subcommands\",\n metavar=\"command\", dest=\"cmd\")\n configure_parser_config(subparsers)\n configure_parser_genome(subparsers)\n configure_parser_motif(subparsers)\n configure_parser_scan(subparsers)\n return parser","def lemma(self) -> str:","def cmd_mdtm(args):","def magic_r(self, parameter_s=''):\n\n start = parameter_s.strip()\n # Identify magic commands even if automagic is on (which means\n # the in-memory version is different from that typed by the user).\n if self.shell.rc.automagic:\n start_magic = '@'+start\n else:\n start_magic = start\n # Look through the input history in reverse\n for n in range(len(self.shell.input_hist)-2,0,-1):\n input = self.shell.input_hist[n]\n if input.startswith('#@'):\n input = input[1:]\n if input != '@r\\n' and \\\n (input.startswith(start) or input.startswith(start_magic)):\n #print 'match',`input` # dbg\n if input.startswith('@'):\n input = magic2python(input)\n #print 'modified',`input` # dbg\n print 'Executing:',input,\n exec input in self.shell.user_ns\n return\n print 'No previous input matching `%s` found.' % start","def __init__(self,cmds):\n\n # Since the list may include multi-line entries, first make sure that\n # they've been all broken up before passing it to magic2python\n cmdlist = map(magic2python,''.join(cmds).split('\\n'))\n self.value = '\\n'.join(cmdlist)","def _magic_docs(self, brief=False, rest=False):\n mman = self.shell.magics_manager\n docs = mman.lsmagic_docs(brief, missing='No documentation')\n\n if rest:\n format_string = '**%s%s**::\\n\\n%s\\n\\n'\n else:\n format_string = '%s%s:\\n%s\\n'\n\n return ''.join(\n [format_string % (magic_escapes['line'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['line'].items())]\n +\n [format_string % (magic_escapes['cell'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['cell'].items())]\n )","def magic_alias(self, parameter_s = ''):\n\n par = parameter_s.strip()\n if not par:\n if self.rc.automagic:\n prechar = ''\n else:\n prechar = '@'\n print 'Alias\\t\\tSystem Command\\n'+'-'*30\n aliases = self.alias_table.keys()\n aliases.sort()\n for alias in aliases:\n print prechar+alias+'\\t\\t'+self.alias_table[alias]\n return\n try:\n alias,cmd = par.split(' ',1)\n except:\n print inspect.getdoc(self.magic_alias)\n return\n nargs = cmd.count('%s')\n if nargs == 0: # simple aliases\n fndef = itpl(\n\"\"\"\ndef magic_${alias}(parameter_s = ''):\n '''Alias to the system command '$cmd' '''\n xsys('$cmd '+str(parameter_s))\n\nself.magic_$alias = magic_$alias\n\"\"\")\n else: # parametric aliases\n fndef = itpl(\n\"\"\"\ndef magic_${alias}(parameter_s = ''):\n '''Alias to the system command '$cmd' '''\n cmd = '$cmd'\n nargs = cmd.count('%s')\n args = str(parameter_s).split()\n\n if len(args) != nargs:\n print 'Incorrect number of arguments:',nargs,'expected.'\n print \"$alias is an alias to: '$cmd'\"\n return\n else:\n cmd_call = cmd % tuple(args)\n xsys(cmd_call)\n\nself.magic_$alias = magic_$alias\n\"\"\")\n try:\n exec fndef in globals(),locals()\n except:\n print self.magic_alias.__doc__\n self.alias_table.update({alias:cmd})","def parse_args(default_minppmm=1000):\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"-p\", \"--plumedir\", required=True,\n help=\"path to input plume file directory\")\n parser.add_argument(\"-r\", \"--regex\", required=False,\n default=\"ang.*_detections/ime_minppmm{}/ang.*_ime_minppmm{}.*\".format(\n default_minppmm, default_minppmm),\n help=\"Regular expression to match for plume files\")\n parser.add_argument(\"-w\", \"--windir\", required=True,\n help=\"path to input wind file directory\")\n parser.add_argument(\"-o\", \"--outfile\", required=True,\n help=\"path to output plume list\")\n parser.add_argument(\"-f\", \"--force\",\n help=\"Force reprocessing of all files (not just the new ones)\",\n action='store_true')\n parser.add_argument(\"-n\", \"--nprocs\", type=int, default=1,\n help=\"number of parallel processes to use; default=1 (sequential)\")\n parser.add_argument(\"--flmode\",\n help=\"Executes script in flightline mode, running on a single flightline\",\n action=\"store_true\")\n args = parser.parse_args()\n return (args.plumedir, args.regex, args.windir, args.outfile,\n args.force, args.nprocs, args.flmode)","def get_input_pattern():\n return '-palign'","def list_param(command):\n namespace = app.main(command)\n assert namespace.command == 'lp' or namespace.command == \"listparam\"","def _parser(s, remainder):\n parser = _ArgumentParser()\n def run():\n return s.parse(parser, remainder)\n parser.run = run\n return parser","def _make_matlab_command(self):\n \n raise NotImplementedError","def setup_parser(self):\n parser = argparse.ArgumentParser(description=DESCRIPTION)\n parser.add_argument('words', metavar='W', nargs='+', help=POSITIONAL_HELP)\n parser.add_argument('-a','--any', dest=\"search_funct\", action=\"store_const\", \n const='any', default='all', help=SEARCH_HELP)\n parser.add_argument('-o','--only-id', action='store_true', help=ID_HELP)\n parser.add_argument('-u', '--update', action='store_true', help=UPDATE_HELP)\n return parser","def parse_args():\n parser = argparse.ArgumentParser(\n description=\"CUDAPOA Python API sample program.\")\n parser.add_argument('-m',\n help=\"Run MSA generation. By default consensusis generated.\",\n action='store_true')\n parser.add_argument('-p',\n help=\"Print output MSA or consensus for each POA group.\",\n action='store_true')\n parser.add_argument('-l',\n help=\"Use long or short read sample data.\",\n action='store_true')\n return parser.parse_args()","def test_lspci_mmv_ubuntu_20_10(self):\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_mmv'], quiet=True),\n self.f_json['ubuntu_20_10_lspci_mmv'])","def test_macro(self):\n env = create_env()\n pkg = create_manifest(\"mock\")\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test)\n cmd2()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([], result)\n\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test)\n if()\n cmd()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([\"INDENTATION\"], result)\n\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test2)\n cmd()\n endmacro()\n macro(test)\n if()\n cmd()\n test2()\n cmd()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([], result)\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test4)\n cmd()\n if()\n cmd()\n endif()\n endmacro()\n macro(test3)\n test4()\n endmacro()\n macro(test2)\n test3()\n if()\n if()\n if()\n cmd()\n test3()\n endif()\n endif()\n endif()\n endmacro()\n macro(test)\n test2()\n if()\n cmd()\n test2()\n else()\n foreach(a b c d e)\n test2()\n endforeach()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)","def parse(self, commands):\n raise NotImplementedError()","def lsmagic(self, parameter_s=''):\n return MagicsDisplay(self.shell.magics_manager, ignore=[])","def run(md_file, interact):\n lines = open(md_file, 'r').readlines()\n blocks = extract_blocks(lines)\n run_py(blocks, interact=interact)","def runMainParser(cmd):\r\n\r\n global local_vars\r\n local_vars={}\r\n # pre-process phrase to group keyword sequences\r\n cmd = hyphenate(cmd)\r\n cmd = pluralize(cmd)\r\n # bitpar\r\n cmd = subprocess.check_output(\"sh ../bitpar/parse '\"+cmd+\"'\",shell=True)\r\n cmd = re.sub('\\n','',cmd)\r\n cmd = label(cmd)\r\n print 'syntax: '+cmd\r\n # update input.txt\r\n subprocess.call(\"cp ../lambda/lambda-defs.txt ../lambda/input.txt\",shell=True)\r\n subprocess.call(\"echo '\"+cmd+\"' >> ../lambda/input.txt\",shell=True)\r\n # lambda calculator & plop\r\n subprocess.call(\"java -jar ../lambda/HCI-auto.jar ../lambda/input.txt > ../lambda/input.tex\",shell=True)\r\n subprocess.call(\"make -C ../lambda input.fml\",shell=True)\r\n fml = subprocess.check_output('cat ../lambda/input.fml',shell=True)[:-1]\r\n if fml == '' or fml == ' {result \\\\ $tt$ \\\\': raise ParseError(cmd+' cannot be interpreted by lambda calculator')\r\n lambdaCalc_output=fml.split('true ')[1][:-2]\r\n #lambda_output_history.append(lambdaCalc_output) #out of scope. how do i fix this?\r\n #lambda_output_history was never initialized\r\n print 'logic: '+lambdaCalc_output\r\n parse(lambdaCalc_output)","def usage():\n print \"\"\"\nUsages:\n ./lmf-merger.py -m file1 file2 outfile\n ./lmf-merger.py -s file1 ...\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\n \"\"\"","def libmagic(self):\n return self.tag(\"libmagic\")","def get_args():\n parser = argparse.ArgumentParser(\n description=\"\"\"summary.py\"\"\")\n parser.add_argument(\n \"--maf\",\n required=True,\n default=None,\n help=\"\"\"The path to the directory containing maf file(s)\"\"\"\n )\n parser.add_argument(\n \"--db\",\n required=True,\n default=None,\n help=\"\"\"The name of the output SQLITE database to hold results\"\"\"\n )\n parser.add_argument(\n \"--metadata-key\",\n required=True,\n dest=\"metadata\",\n type=str,\n help=\"\"\"The primary species in the alignment (e.g. the one on top in the MAF file)\"\"\"\n )\n parser.add_argument(\n \"--alignment-length\",\n dest=\"align\",\n type=int,\n default=25,\n help=\"\"\"The minimum acceptable alignment length\"\"\"\n )\n parser.add_argument(\n \"--consensus-length\",\n dest=\"consensus\",\n type=int,\n default=25,\n help=\"\"\"The minimum acceptable consensus length\"\"\"\n )\n return parser.parse_args()","def apms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApmReferenceArgs']]]]:\n return pulumi.get(self, \"apms\")","def magic_lf(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^-')","def arg_parse():\n p = ap.ArgumentParser()\n p.add_argument()\n return p.parse_args()","def parse_lines(lines, packages):\n for line in lines:\n x = line.split(' ')\n cmd = x[0].upper()\n #LOG.debug(cmd)\n if 'LIST' in cmd:\n getattr(commands, cmd)(p)\n else:\n getattr(commands, cmd)(line, p)","def saml_args(subparsers: argparse.ArgumentParser) -> argparse.ArgumentParser:\n example_usage = \"\"\"example usage:\n\n ticketsplease saml --adfs-config '...' --target-user-guid '...' --dkm-key '...' --assertion\n ticketsplease saml --adfs-config-file config.bin --domain company.com --target-user tUser --domain-username user --domain-password password --dc-ip 10.10.10.10\n \"\"\"\n\n saml_parser = subparsers.add_parser(\n \"saml\",\n description=\"Generate a Golden SAML token\",\n epilog=example_usage,\n formatter_class=argparse.RawDescriptionHelpFormatter,\n )\n saml_parser.add_argument(\n \"--adfs-config\",\n type=str,\n help=\"ADFS configuration settings.\",\n )\n saml_parser.add_argument(\n \"--adfs-config-file\",\n type=str,\n help=\"File containing the ADFS configuration settings.\",\n )\n saml_parser.add_argument(\n \"--domain\",\n type=str,\n help=\"Target domain the Golden SAML token is generated for (i.e. company.com).\",\n )\n saml_parser.add_argument(\n \"--target-user\",\n type=str,\n help=\"Username of the account to generate the Golden SAML token for.\",\n )\n saml_parser.add_argument(\n \"--target-user-upn\",\n type=str,\n help=\"UPN of the account to generate the Golden SAML token for (if not provided, retrieved via LDAP).\",\n )\n saml_parser.add_argument(\n \"--target-user-guid\",\n type=str,\n help=\"GUID of the account to generate the Golden SAML token for (if not provided, retrieved via LDAP).\",\n )\n saml_parser.add_argument(\n \"--dkm-key\",\n type=str,\n help=\"DKM Key (if not provided, retrieved via LDAP).\",\n )\n saml_parser.add_argument(\n \"--assertion\",\n action=\"store_true\",\n help=\"Extract the SAML Assertion from the token.\",\n )\n # LDAP/WMIC options\n domain_saml_options = saml_parser.add_argument_group(\"ldap/wmic arguments\")\n domain_saml_options.add_argument(\n \"--domain-username\",\n type=str,\n help=\"Username to perform LDAP/WMIC operations with.\",\n )\n domain_saml_options.add_argument(\n \"--domain-password\",\n type=str,\n help=\"Password of the account to perform LDAP/WMIC operations with.\",\n )\n domain_saml_options.add_argument(\n \"--dc-ip\",\n type=str,\n help=\"IP address of the target Domain Controller.\",\n )\n\n return saml_parser","def _register_commands(self):\n cmds = []\n cmd_help = CommandParser(\"help\", \"Show help for a command.\")\n cmd_help.add_argument(\n \"command\",\n nargs=\"*\",\n help=\"The command to get help for. Specify multiple names to get help for subcommands.\",\n )\n cmd_help.add_argument(\"-m\", \"--module\", help=\"List all commands from the given module\")\n cmd_help.add_argument(\n \"-f\",\n \"--full\",\n action=\"store_true\",\n help='Include descriptions in the \"all\" help output.',\n )\n cmds.append(cmd_help)\n\n target_mod = CommandParser()\n target_mod.add_argument(\"module\", nargs=\"+\", help=\"Target module(s)\")\n target_mod.add_argument(\n \"-p\",\n \"--protocol\",\n action=\"store_const\",\n const=\"protocol\",\n default=\"feature\",\n dest=\"mtype\",\n help=\"Target is a protocol module\",\n )\n cmd_module = CommandParser(\"module\", \"Manage and query ZeroBot modules\")\n add_subcmd = cmd_module.make_adder(metavar=\"OPERATION\", dest=\"subcmd\", required=True)\n add_subcmd(\"load\", description=\"Load a module\", parents=[target_mod])\n add_subcmd(\"reload\", description=\"Reload a module\", parents=[target_mod])\n subcmd_list = add_subcmd(\"list\", description=\"List available modules\")\n subcmd_list.add_argument(\"-l\", \"--loaded\", action=\"store_true\", help=\"Only loaded modules\")\n list_group = subcmd_list.add_mutually_exclusive_group()\n default_categories = [\"protocol\", \"feature\"]\n list_group.add_argument(\n \"-f\",\n \"--feature\",\n action=\"store_const\",\n const=[\"feature\"],\n dest=\"category\",\n default=default_categories,\n help=\"Only feature modules\",\n )\n list_group.add_argument(\n \"-p\",\n \"--protocol\",\n action=\"store_const\",\n const=[\"protocol\"],\n dest=\"category\",\n default=default_categories,\n help=\"Only protocol modules\",\n )\n add_subcmd(\"info\", description=\"Show module information\", parents=[target_mod])\n cmds.append(cmd_module)\n\n save_reload_args = CommandParser()\n save_reload_args.add_argument(\n \"config_file\",\n nargs=\"*\",\n help=\"Name of config file (without .toml extension). Omit to affect all loaded config files.\",\n )\n set_reset_args = CommandParser()\n set_reset_args.add_argument(\"config_file\", help=\"Name of config file (without .toml extension)\")\n cmd_config = CommandParser(\"config\", \"Manage configuration\")\n add_subcmd = cmd_config.make_adder(metavar=\"OPERATION\", dest=\"subcmd\", required=True)\n add_subcmd(\"save\", description=\"Save config files to disk\", parents=[save_reload_args])\n subcmd_savenew = add_subcmd(\"savenew\", description=\"Save config file to a new path\")\n subcmd_savenew.add_argument(\"config_file\", help=\"Name of config file (without .toml extension)\")\n subcmd_savenew.add_argument(\"new_path\", help=\"The path to save the config file to\")\n add_subcmd(\n \"reload\",\n description=\"Reload config files from disk\",\n parents=[save_reload_args],\n )\n subcmd_set = add_subcmd(\"set\", description=\"Modify config settings\", parents=[set_reset_args])\n subcmd_set.add_argument(\n \"key_path\",\n help=\"The config key to set. Subkeys are separated by dots, e.g. 'Core.Backup.Filename'\",\n )\n subcmd_set.add_argument(\"value\", nargs=\"?\", help=\"The new value. Omit to show the current value.\")\n subcmd_reset = add_subcmd(\n \"reset\",\n description=\"Reset config settings to last loaded value\",\n parents=[set_reset_args],\n )\n subcmd_reset.add_argument(\n \"key_path\",\n nargs=\"?\",\n help=(\n \"The config key to set. Subkeys are separated by dots, \"\n \"e.g. 'Core.Backup.Filename'. If omitted, the entire \"\n \"config will be reset.\"\n ),\n )\n subcmd_reset.add_argument(\n \"-d\",\n \"--default\",\n action=\"store_true\",\n help=\"Set the key to its default value instead. Effectively unsets a config key.\",\n )\n cmds.append(cmd_config)\n\n cmd_version = CommandParser(\"version\", \"Show version information\")\n cmds.append(cmd_version)\n\n cmd_restart = CommandParser(\"restart\", \"Restart ZeroBot.\")\n cmd_restart.add_argument(\"msg\", nargs=\"*\", help=\"Message sent to protocol modules as a reason\")\n cmds.append(cmd_restart)\n\n cmd_quit = CommandParser(\"quit\", \"Shut down ZeroBot.\")\n cmd_quit.add_argument(\"msg\", nargs=\"*\", help=\"Message sent to protocol modules as a reason\")\n cmds.append(cmd_quit)\n\n cmd_wait = CommandParser(\"wait\", \"Execute a command after a delay\")\n cmd_wait.add_argument(\n \"delay\",\n help=\"Amount of time to delay. Accepts the following modifier suffixes: 'ms', 's' (default), 'm', 'h'.\",\n )\n cmd_wait.add_argument(\"command\", help=\"Command to delay\")\n cmd_wait.add_argument(\"args\", nargs=argparse.REMAINDER, help=\"Command arguments\")\n cmds.append(cmd_wait)\n\n cmd_cancel = CommandParser(\"cancel\", \"Cancel a waiting command\")\n cancel_group = cmd_cancel.add_mutually_exclusive_group()\n cancel_group.add_argument(\"id\", type=int, nargs=\"?\", help=\"The ID of a waiting command\")\n cancel_group.add_argument(\"-l\", \"--list\", action=\"store_true\", help=\"List currently waiting commands\")\n cmds.append(cmd_cancel)\n\n cmd_backup = CommandParser(\"backup\", \"Create a database backup\")\n cmd_backup.add_argument(\"name\", type=Path, help=\"Backup filename\")\n cmds.append(cmd_backup)\n\n self.command_register(\"core\", *cmds)","def parsemeta(metalines):\n def parseline(line):\n res = [val.strip() for val in line[5:].split(u':', 1)]\n key, value = (res[0], res[1]) if len(res) == 2 else (res[0], u'')\n if re.match(r'^-?\\d*[\\.|,]?\\d+$', value):\n value = float(value)\n elif re.match(r'^\\[(.*)\\]', value):\n value = [val.strip() for val in value[1:-1].split(u',')]\n value = [float(val) if re.match(r'^-?\\d*[\\.|,]?\\d+$', val) else val for val in value]\n return key, value\n return OrderedDict(parseline(line) for line in metalines if line.startswith(u'#CTE_'))","def runMainParser(cmd):\n\n global local_vars\n local_vars={}\n # pre-process phrase to group keyword sequences\n cmd = hyphenate(cmd)\n cmd = pluralize(cmd)\n # bitpar\n cmd = subprocess.check_output(\"sh ../bitpar/parse '\"+cmd+\"'\",shell=True)\n cmd = re.sub('\\n','',cmd)\n cmd = label(cmd)\n print 'syntax: '+cmd\n # update input.txt\n subprocess.call(\"cp ../lambda/lambda-defs.txt ../lambda/input.txt\",shell=True)\n subprocess.call(\"echo '\"+cmd+\"' >> ../lambda/input.txt\",shell=True)\n # lambda calculator & plop\n subprocess.call(\"java -jar ../lambda/HCI-auto.jar ../lambda/input.txt > ../lambda/input.tex\",shell=True)\n subprocess.call(\"make -C ../lambda input.fml\",shell=True)\n fml = subprocess.check_output('cat ../lambda/input.fml',shell=True)[:-1]\n if fml == '' or fml == ' {result \\\\ $tt$ \\\\': raise ParseError(cmd+' cannot be interpreted by lambda calculator')\n lambdaCalc_output=fml.split('true ')[1][:-2]\n #lambda_output_history.append(lambdaCalc_output) #out of scope. how do i fix this?\n #lambda_output_history was never initialized\n print 'logic: '+lambdaCalc_output\n parse(lambdaCalc_output)","def parse_block_math(self, m):\n self.tokens.append({\n 'type': 'block_math',\n 'text': m.group(1)\n })","def parse(self, message):\n # The message does not contain the command name.\n # self.args will become the parsed Namespace object.\n\n # For command aliases, add the prepend string\n message = \"{} {}\".format(self.arguments_prepend, message)\n\n parser = self.get_parser()\n\n message = message.replace(\"'\", \"<<APOS>>\")\n message = message.replace('\\\\\"', \"<<QUOT>>\") # explicit \\\"\n try:\n message = shlex.split(message, posix=False)\n # posix=False does not remove quotes\n message = [m.strip('\"') for m in message]\n except ValueError as e:\n # raised if shlex detects fucked up quotemarks\n # message = message.split()\n raise CommandParsingError(\n \"Unmatched quotemark. Use \\\\\\\" to escape a literal quotemark\"\n ) from e\n message = [w.replace(\"<<APOS>>\", \"'\") for w in message]\n message = [w.replace(\"<<QUOT>>\", '\"') for w in message]\n try:\n # Can throw ArgumentError\n self.args = parser.parse_args(message)\n except CommandParsingHelp as error:\n # The error contains the get_usage string but I'm going to just\n # ignore that\n raise (\n MyFaultError if self.__doc__ is None else CommandUsageMessage\n )(self.make_command_help_string()) from error","def lammps(step, atomnum, boxbounds, addson = ''):\r\n\r\n line = 'ITEM: TIMESTEP\\n'\r\n line += str(step) + '\\n'\r\n\r\n line += 'ITEM: NUMBER OF ATOMS\\n'\r\n line += str(atomnum) + '\\n'\r\n\r\n line += 'ITEM: BOX BOUNDS pp pp pp\\n'\r\n line += '%.6f %.6f\\n' %(boxbounds[0, 0], boxbounds[0, 1])\r\n line += '%.6f %.6f\\n' %(boxbounds[1, 0], boxbounds[1, 1])\r\n if boxbounds.shape[0] == 3:\r\n line += '%.6f %.6f\\n' %(boxbounds[2, 0], boxbounds[2, 1])\r\n else:\r\n line += '%.6f %.6f\\n' %(-0.5, 0.5)\r\n\r\n line += 'ITEM: ATOMS id type x y z %s\\n' %addson\r\n\r\n return line","def readCommand( argv ): ## argv belongs to the 'sys'-library and can be called through sys.argv. The function reads the console's comand line argument and passes it to a variable like so: args = sys.argv[1:]\n from optparse import OptionParser ## Option Parser is a powerful library for passing command line options (an advanced args) if you like. It allows you to add options by defining attributes. \n usageStr = \"\"\" \n USAGE: python pacman.py <options> \n EXAMPLES: (1) python pacman.py\n - starts an interactive game\n (2) python pacman.py --layout smallClassic --zoom 2\n OR python pacman.py -l smallClassic -z 2\n - starts an interactive game on a smaller board, zoomed in\n \"\"\" \n parser = OptionParser(usageStr) ## This creates the Option Parser instance. It also passes the usageStr which functions as a little help-text for the user.\n\n ### In this section all the option strings are defined. Typically each option has one short option string and one long option string. For example the parser.add_option('-n'... has '-n' as short and '--numGames' as the long option string. Both have the same effect. The option argument will be the same and be saved as the variabme 'numGames'. \n parser.add_option('-n', '--numGames', dest='numGames', type='int', \n help=default('the number of GAMES to play'), metavar='GAMES', default=1) ## the syntax for the options is (based on the example in this line) --n 3. This means that the value '3' would be assigned to the variable numGames.\n parser.add_option('-l', '--layout', dest='layout',\n help=default('the LAYOUT_FILE from which to load the map layout'), #The instance -> 'options.layout' defines the layout_file from which to load the map layout; DEFAULT = medium_classic\n metavar='LAYOUT_FILE', default='mediumClassic')\n parser.add_option('-p', '--pacman', dest='pacman',\n help=default('the agent TYPE in the pacmanAgents module to use'), #The instance -> 'options.pacman' defines which of the agent TYPE in the pacmanAgents moduleto use.\n metavar='TYPE', default='KeyboardAgent')\n parser.add_option('-t', '--textGraphics', action='store_true', dest='textGraphics',\n help='Display output as text only', default=False)\n parser.add_option('-q', '--quietTextGraphics', action='store_true', dest='quietGraphics',\n help='Generate minimal output and no graphics', default=False)\n parser.add_option('-g', '--ghosts', dest='ghost',\n help=default('the ghost agent TYPE in the ghostAgents module to use'),\n metavar = 'TYPE', default='RandomGhost')\n parser.add_option('-k', '--numghosts', type='int', dest='numGhosts',\n help=default('The maximum number of ghosts to use'), default=4)\n parser.add_option('-z', '--zoom', type='float', dest='zoom',\n help=default('Zoom the size of the graphics window'), default=1.0)\n parser.add_option('-f', '--fixRandomSeed', action='store_true', dest='fixRandomSeed',\n help='Fixes the random seed to always play the same game', default=False)\n parser.add_option('-r', '--recordActions', action='store_true', dest='record',\n help='Writes game histories to a file (named by the time they were played)', default=False)\n parser.add_option('--replay', dest='gameToReplay',\n help='A recorded game file (pickle) to replay', default=None)\n parser.add_option('-a','--agentArgs',dest='agentArgs',\n help='Comma separated values sent to agent. e.g. \"opt1=val1,opt2,opt3=val3\"')\n parser.add_option('-x', '--numTraining', dest='numTraining', type='int',\n help=default('How many episodes are training (suppresses output)'), default=0)\n parser.add_option('--frameTime', dest='frameTime', type='float',\n help=default('Time to delay between frames; <0 means keyboard'), default=0.1)\n parser.add_option('-c', '--catchExceptions', action='store_true', dest='catchExceptions',\n help='Turns on exception handling and timeouts during games', default=False)\n parser.add_option('--timeout', dest='timeout', type='int',\n help=default('Maximum length of time an agent can spend computing in a single game'), default=30)\n\n #ONCE ALL THE OPTIONS HAVE BEEN DEFINED, optparse is instructed to parse the programm's command line.\n ##> The parser.parse_args() returns two values:\n ### (A) OPTIONS: An object containing values for all of your options e.g.:e.g. if --file takes a single string argument, then options.file will be the filename supplied by the user, or None if the user did not supply that option\n ### (B) ARGS: The list of positional arguments leftover after parsing options (we call this here otherjunk)\n options, otherjunk = parser.parse_args(argv) ## if the user happens to accidentally enter a command other than the specified arguments specified by parser.add_option it is passed to otherjunk\n if len(otherjunk) != 0: ## if there actually ends up to be a value in the otherjunk the program raises an Exception.\n raise Exception('Command line input not understood: ' + str(otherjunk))\n args = dict() # ARGS IS THE VARIABLE THAT IS BEING RETURNED BY THE readCommand function.\n\n # Fix the random seed\n if options.fixRandomSeed: random.seed('cs188') # 'random.seed' is part of the random class. The random.seed([x]) command initialises a standard random number. Optional argument x can be any hashable object. \n\n # Choose a layout\n args['layout'] = layout.getLayout( options.layout ) # REF_LAYOUT111: layout.py --> This function returns the layout object that was created by the layout class via the getlayout function. This contains the height, width, walls, food, captules and agent positions etc.\n if args['layout'] == None: raise Exception(\"The layout \" + options.layout + \" cannot be found\")\n\n # Choose a Pacman agent\n noKeyboard = options.gameToReplay == None and (options.textGraphics or options.quietGraphics) ## noKeyboard is set to TRUE if the user chooses the --replay and text- or silent graphics option.\n ##print noKeyboard\n pacmanType = loadAgent(options.pacman, noKeyboard) ## [see REFERENCE_001]: the loadAgent function takes the pacman argument the user passed into the command line as the option--pacman option identifies the appropriate agent (which may be the programmed agent or whost agent). \n agentOpts = parseAgentArgs(options.agentArgs) ##Passes the option.agentArgs which was captured by the user's console input into the agentOps variable. agentArgs is: \"Comma separated values sent to agent. e.g. \"opt1=val1,opt2,opt3=val3. The ParseAgentArgs function converts the option - value pairings into a dictionary formatted opts[opt1] = val1. \n if options.numTraining > 0: ##numTraining was captured by the user's console input and designates how many games are training games which means that the output remains surpressed.\n args['numTraining'] = options.numTraining ## This takes the user's input as the -x or --numTraining and passes it to the args dictionary with the numTraining key as the args['numTraining'] variable.\n if 'numTraining' not in agentOpts: agentOpts['numTraining'] = options.numTraining ## This integrates the variable entered into as training rounds in the agentOpts variable.\n pacman = pacmanType(**agentOpts) ## REFERENCE002 ##Instantiate Pacman with agentOpts. ## The variable pacmanType contains a reference to agent module loaded by the load Agent function. This function does not cause the module to be instanciated. This happens when here ## See[REFERENCE_001]: ## The * and ** will 'soak up' any remaining values not otherwise accounted for. In this case these options are basically the agent options the user can input.\n ## agentOpts contains the opts dictionary = {opt1:val1, opt2:val2, opt3:val3}; it also contains the numTraining variable as the ['numTraining'] key. As such it has the following structure. {opt1:val1,opt2:val2,opt3:val3, numTraining:int}.\n args['pacman'] = pacman ## This passes the instanciated object to the agent dictionary containing the pacman key.\n\n # Don't display training games\n if 'numTrain' in agentOpts: ## Checks whether the user has determined a certain number of training games. If they did, the number is passed on as an int to the options.numQuiet and option.numIgnore variables.\n options.numQuiet = int(agentOpts['numTrain']) \n options.numIgnore = int(agentOpts['numTrain'])\n\n # Choose a ghost agent\n ghostType = loadAgent(options.ghost, noKeyboard) ## The options.ghost variable contains the user's ghost type preference as specified in the console.The user can choose between -g RandomGhost which is A ghost that chooses a legal action uniformly at random OR DirectionalGhost, a ghost that prefers to rush Pacman, or flee when scared.\n args['ghosts'] = [ghostType( i+1 ) for i in range( options.numGhosts )] #instanciates as many ghost agents as the player requested by entering the desired number as -k', '--numghosts'in the console.\n\n # Choose a display format ##contains whether the game output is displayed as minimal output and no graphics (-q) text only (-t) or via graphicsDiplay (standard)\n if options.quietGraphics: \n import textDisplay\n args['display'] = textDisplay.NullGraphics()\n elif options.textGraphics:\n import textDisplay\n textDisplay.SLEEP_TIME = options.frameTime\n args['display'] = textDisplay.PacmanGraphics()\n else:\n import graphicsDisplay ## This refers to the module that is responsible for the graphical representation of the game.\n args['display'] = graphicsDisplay.PacmanGraphics(options.zoom, frameTime = options.frameTime) ## This line instanciates the PacmanGraphics class from the graphicsDisplay module and passes the reference to the args['display'] dictionary.\n args['numGames'] = options.numGames \n args['record'] = options.record\n args['catchExceptions'] = options.catchExceptions\n args['timeout'] = options.timeout\n\n # Special case: recorded games don't use the runGames method or args structure\n if options.gameToReplay != None:\n print 'Replaying recorded game %s.' % options.gameToReplay \n import cPickle\n f = open(options.gameToReplay)\n try: recorded = cPickle.load(f)\n finally: f.close()\n recorded['display'] = args['display']\n replayGame(**recorded)\n sys.exit(0)\n\n return args #returns the args-dictionary which contains:\n ##args['pacman'] which contains a dictionary of dictionaries of the agent that was loaded into args['numtraining'] = {agentOpts[opt1]: val1 ; agentOpts[opt2]:val2; agentOpts[opt3]:val3}\n ##args['layout'] - this function returns the layout object that was created by the layout class via the getlayout function.\n ##args['numTraining'] which contains which designates how many games are training games which means that the output remains surpressed\n ##args['ghosts'] - contains the instanciated ghost agents in line with the number the user specified\n ##args['display'] - contains whether the game output is displayed as minimal output and no graphics (-q) text only (-t) or via graphicsDiplay (standard)\n ##args['numGames'] - the number of GAMES to play\n ##args['record'] - Writes game histories to a file (named by the time they were played)\n ##args['catchExceptions'] = options.catchExceptions - Turns on exception handling and timeouts during games\n ##args['timeout'] = options.timeout -Maximum length of time an agent can spend computing in a single game","def _parse_markdown(self):\n renderer = MyRenderer()\n md = mistune.Markdown(renderer=renderer)\n md.render(self._markdown_text)\n self._bash_commands = renderer._bash_commands","async def getHelp(ctx, cmd):\n wikiMods = discord.utils.get(ctx.message.author.guild.roles, name=\"Wiki Moderator\")\n cmdInfo = next((c for c in COMMAND_INFO if c[\"name\"] == cmd or cmd in c[\"aliases\"]), None)\n if cmdInfo == None:\n return assembleEmbed(\n title=f\"`{cmd}`\",\n desc=\"Cannot find command with this name. Try again buddy.\",\n webcolor=\"red\"\n )\n else:\n roles = [(discord.utils.get(ctx.message.author.guild.roles, name=r)) for r in cmdInfo['access']]\n commandFields = [\n {\n \"name\": \"Parameters\",\n \"value\": \"\\n\".join([f\"`{p['name']}` - {p['description']}\" for p in cmdInfo['parameters']]) if len(cmdInfo['parameters']) > 0 else \"`none`\",\n \"inline\": False\n }\n ]\n # If command has flags show those, if not do nothing\n if 'flags' in cmdInfo:\n commandFields.append({\n \"name\": \"Flags\",\n \"value\": \"\\n\".join([f\"`-{u['name']}` - {u['description']}\" for u in cmdInfo['flags']]),\n \"inline\": False\n })\n # Add available roles\n commandFields.extend([\n {\n \"name\": \"Usage\",\n \"value\": \"\\n\".join([f\"`{u['cmd']}` - {u['result']}\" for u in cmdInfo['usage']]),\n \"inline\": False\n },\n {\n \"name\": \"Available To\",\n \"value\": \"\\n\".join([f\"{r.mention}\" for r in roles]),\n \"inline\": False\n }\n ]\n )\n return assembleEmbed(\n title=f\"`!{cmdInfo['name']}`\",\n desc=f\"{cmdInfo['description']}\",\n fields=commandFields,\n webcolor=\"gold\"\n )","def parse():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', default='ml-1m', help='which dataset to use')\n args = parser.parse_args()\n main(args)","def _parse_word(self, token, ctxinfo) :\n ignore = False\n if token.startswith(\"|\") and token.endswith(\"|\") : # regular token\n token = token[1:-1]\n token_parts = token.rsplit( \"_\", 1 )\n if len(token_parts) == 2 :\n lemma_and_index, pos = token_parts\n lemma_parts = lemma_and_index.rsplit( \":\", 1 )\n if len(lemma_parts) == 2 : \n lemma, index = lemma_parts\n if lemma.endswith(\"\\\\\") :\n lemma = lemma[:-1] # separator was \\: \n else :\n ignore = True\n else :\n ignore = True\n if ignore :\n ctxinfo.warn(\"Ignoring bad token `{token}`\", token=token)\n return None\n else : \n return (lemma, index, pos)","def __init__(\n self,\n terminators: Optional[Iterable[str]] = None,\n multiline_commands: Optional[Iterable[str]] = None,\n aliases: Optional[Dict[str, str]] = None,\n shortcuts: Optional[Dict[str, str]] = None,\n ) -> None:\n self.terminators: Tuple[str, ...]\n if terminators is None:\n self.terminators = (constants.MULTILINE_TERMINATOR,)\n else:\n self.terminators = tuple(terminators)\n self.multiline_commands: Tuple[str, ...] = tuple(multiline_commands) if multiline_commands is not None else ()\n self.aliases: Dict[str, str] = aliases if aliases is not None else {}\n\n if shortcuts is None:\n shortcuts = constants.DEFAULT_SHORTCUTS\n\n # Sort the shortcuts in descending order by name length because the longest match\n # should take precedence. (e.g., @@file should match '@@' and not '@'.\n self.shortcuts = tuple(sorted(shortcuts.items(), key=lambda x: len(x[0]), reverse=True))\n\n # commands have to be a word, so make a regular expression\n # that matches the first word in the line. This regex has three\n # parts:\n # - the '\\A\\s*' matches the beginning of the string (even\n # if contains multiple lines) and gobbles up any leading\n # whitespace\n # - the first parenthesis enclosed group matches one\n # or more non-whitespace characters with a non-greedy match\n # (that's what the '+?' part does). The non-greedy match\n # ensures that this first group doesn't include anything\n # matched by the second group\n # - the second parenthesis group must be dynamically created\n # because it needs to match either whitespace, something in\n # REDIRECTION_CHARS, one of the terminators, or the end of\n # the string (\\Z matches the end of the string even if it\n # contains multiple lines)\n #\n invalid_command_chars = []\n invalid_command_chars.extend(constants.QUOTES)\n invalid_command_chars.extend(constants.REDIRECTION_CHARS)\n invalid_command_chars.extend(self.terminators)\n # escape each item so it will for sure get treated as a literal\n second_group_items = [re.escape(x) for x in invalid_command_chars]\n # add the whitespace and end of string, not escaped because they\n # are not literals\n second_group_items.extend([r'\\s', r'\\Z'])\n # join them up with a pipe\n second_group = '|'.join(second_group_items)\n # build the regular expression\n expr = rf'\\A\\s*(\\S*?)({second_group})'\n self._command_pattern = re.compile(expr)","def parse(self, filehandle):\n l = filehandle.readline()\n if l.split()[0] != '##maf':\n return\n else:\n self.setpar(l.split()[1:])\n\n l=filehandle.readline()\n while l:\n la = l.split()\n## print la\n if(len(la)==0 or la[0]=='#'):\n## print \"skipping\"\n 1\n elif(la[0]=='a'):\n## print \"reading alignment\"\n self.readalign(la[1:], filehandle)\n else:\n## print \"end of records\"\n return\n\n l=filehandle.readline()","def law(self, line):\n line = line.strip()\n if not line:\n logger.error(r\"the command passed to %law must not be empty\")\n return\n\n # build the full command\n cmd = \"law \" + line\n if line_cmd:\n cmd = \"{} && {}\".format(line_cmd, cmd)\n logger.debug(\"running law command '{}'\".format(cmd))\n\n # run it\n return self._run_bash(cmd)","def parse_args():\n parser = argparse.ArgumentParser(description=__doc__)\n parser.add_argument('--version', action='version',\n version=\"iswitch version \" + get_version())\n\n # Can't require a subparser because of need to maintain\n # backwards compatibility with Python 3.6\n subparsers = parser.add_subparsers(\n dest='command', help='command')\n\n pwd_parser = subparsers.add_parser(\"pwd\",\n help='Print working directory/collection')\n pwd_parser.add_argument('--verbose', '-v', action='store_true', default=False,\n help='Print verbose information for troubleshooting')\n\n cd_parser = subparsers.add_parser(\"cd\",\n help='Change working directory/collection')\n cd_parser.add_argument('--verbose', '-v', action='store_true', default=False,\n help='Print verbose information for troubleshooting')\n cd_parser.add_argument('directory', default=None, nargs='?',\n help='Directory to change to')\n\n ls_parser = subparsers.add_parser(\"ls\",\n help='List collections or data objects')\n ls_parser.add_argument('--verbose', '-v', action='store_true', default=False,\n help='Print verbose information for troubleshooting')\n ls_parser.add_argument('queries', default=None, nargs='*',\n help='Collection, data object or data object wildcard')\n ls_parser.add_argument(\"-m\", \"--format\", dest='format', default='plain',\n help=\"Output format\", choices=['plain', 'json', 'csv', \"yaml\"])\n ls_parser.add_argument(\"-s\", \"--sort\", dest=\"sort\", default='name',\n help=\"Propery to use for sorting\", choices=['name', 'ext', 'size', 'date', \"unsorted\"])\n ls_parser.add_argument(\"-H\", \"--hr-size\", default='default', dest=\"hrsize\",\n help=\"Whether to print human-readable sizes [yes,no,default].\" +\n \"By default, enable human-readable for text output, disable for other formats.\",\n choices=['default', 'yes', 'no'])\n ls_parser.add_argument('--recursive', '-r', action='store_true', default=False,\n help='Include contents of subcollections')\n ls_parser.add_argument('-l', action='store_true', default=False,\n help='Display replicas with size, resource, owner, date')\n ls_parser.add_argument('-L', action='store_true', default=False,\n help='like -l, but also display checksum and physical path')\n\n help_hrs = \" (you can optionally use human-readable sizes, like \\\"2g\\\" for 2 gigabytes)\"\n find_parser = subparsers.add_parser(\"find\",\n help='Find data objects by property')\n find_parser.add_argument('--verbose', '-v', action='store_true', default=False,\n help='Print verbose information for troubleshooting')\n find_parser.add_argument('queries', default=None, nargs='*',\n help='Collection, data object or data object wildcard')\n find_parser.add_argument('--print0', '-0', action='store_true', default=False,\n help='Use 0 byte delimiters between results')\n find_parser.add_argument(\n \"--dname\",\n help=\"Wildcard filter for data object name\")\n find_parser.add_argument(\n \"--owner-name\",\n help=\"Filter for data object owner name (excluding zone)\")\n find_parser.add_argument(\"--owner-zone\",\n help=\"Filter for data object owner zone\")\n find_parser.add_argument(\"--resc-name\",\n help=\"Filter for data object resource\")\n find_parser.add_argument(\n \"--minsize\",\n help=\"Filter for minimum data object size\" +\n help_hrs)\n find_parser.add_argument(\n \"--maxsize\",\n help=\"Filter for maximum data object size\" +\n help_hrs)\n find_parser.add_argument(\n \"--size\",\n help=\"Filter for (exact) data object size\" +\n help_hrs)\n\n if len(sys.argv) == 1:\n parser.print_help()\n parser.exit()\n\n return vars(parser.parse_args())","def default(self, line):\n lexer = shlex.shlex(line)\n lexer.wordchars += \"-\"\n lexer = list(lexer)\n arg = []\n func_name = \"\"\n idx = 0\n in_paren = False\n\n while idx < len(lexer):\n if lexer[idx][0].islower() is True and func_name == \"\":\n func_name = lexer[idx]\n elif in_paren is True:\n if lexer[idx] == \"[\":\n idx_start = lexer.index(\"[\")\n idx_end = lexer.index(\"]\")\n list_str = \"\".join(lexer[idx_start:idx_end + 1])\n arg.append(eval(list_str))\n idx = idx_end\n if lexer[idx] == \"{\":\n dict_str = \"\".join(lexer[idx:-1])\n dict_str = dict_str.replace(\"'\", '\"')\n arg.append(json.loads(dict_str))\n idx = len(lexer) - 1\n if lexer[idx] not in \",)\":\n arg.append(lexer[idx].replace('\"', \"\").replace(\"'\", \"\"))\n elif lexer[idx] == \"(\":\n in_paren = True\n elif lexer[idx] != \".\":\n arg.append(lexer[idx].replace('\"', \"\").replace(\"'\", \"\"))\n idx += 1\n\n cmd_list = (\"all\", \"count\", \"show\", \"destroy\", \"update\")\n if func_name in cmd_list:\n eval(\"self.do_\" + func_name + \"(arg)\")","def cmdline_parser():\n parser = argparse.ArgumentParser(description=\"\"\" \"\"\")\n parser.add_argument(\"-g\", \"--gta\",\n help=\"\"\"gta sequences\"\"\",\n dest=\"gta\",\n required=True)\n return parser","def OnModCommand(self, message):\n\n argument = QuotedString(quoteChar='(', endQuoteChar=')', escChar='\\\\') | Regex(r'(?!--)[^\\s]+')\n arguments = ZeroOrMore(argument)\n command = Word(alphas)\n kwarg = command+Suppress(Optional(Literal('=')))+argument\n kwargs = Suppress(Literal('--')) + ZeroOrMore(kwarg.setParseAction(tuple))\n commandWithArgs = StringStart() + command + Group(arguments) + Group(Optional(kwargs)) + StringEnd()\n\n try:\n pCommand, args, kw = commandWithArgs.parseString(message)\n except ParseException as e:\n self.PutModule('Invalid command {}'.format(e))\n return znc.CONTINUE\n\n\n if not pCommand:\n self.PutModule('No command')\n return znc.CONTINUE\n\n method = getattr(self, 'cmd_' + pCommand.lower(), None)\n\n if method is None:\n self.PutModule('Invalid command {}'.format(pCommand))\n return znc.CONTINUE\n\n try:\n method(*args, **dict(list(kw)))\n except TypeError as e:\n self.PutModule('Usage: {}{}\\n{}'.format(pCommand, signature(method), e))\n return znc.CONTINUE\n\n return znc.CONTINUE","def magic(self, alias):\n if alias in self.aliases:\n return self.aliases[alias]\n else:\n return \"%%{}\\n\".format(alias)","def parseCmdLine(cmdLine):\n files=[]\n modifiers=[]\n for i in range(len(cmdLine)):\n arg = cmdLine[i]\n if arg[:2] != '--':\n files = cmdLine[i:]\n return (modifiers, files)\n \n arg = arg[2:]\n parts = arg.split('=',1)\n modifiers.append((parts[0], parts[1]))\n return (modifiers, files)","def help_util():\r\n for cmd, f in COMMANDS.items():\r\n print(\"POM \" + cmd + \":\")\r\n print(f.__doc__.lstrip(\"\\n\"))","def autosuggest_ml(self, suggest, focus=None, clip=None, display='full',\n format='json', lang=None):\n\n params = {\n 'addr': suggest,\n 'display': display,\n 'format': format,\n 'lang': lang or self.lang,\n }\n if focus:\n params.update({\n 'focus': focus\n })\n if clip:\n params.update({\n 'clip': clip\n })\n\n return self._request('/autosuggest-ml', params)","def parse(self, command_line=sys.argv[1:]):\n return self._parser.parse_args(command_line)","def pymssql_mixin_parser_kwargs():\n config_path = \"./config.json\"\n config: Dict[str, Any] = {}\n dump_json_file(config, config_path)\n\n model = Model(name=\"test\", version=\"0.0.1\")\n model_path = \"./model.pkl\"\n dump_pickle_file(model, model_path)\n\n mssql_uri = \"mssql+pymssql://mssql?test\"\n\n argv = [\n \"--config\",\n config_path,\n \"--model\",\n model_path,\n \"--mssql-uri\",\n mssql_uri,\n ]\n parser = ArgumentParser()\n return {\"argv\": argv, \"parser\": parser}","def _parse_args():\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\n\n parser.add_argument('EXPRESSION', action=\"store\", type=str, help=\"expression string to evaluate\")\n parser.add_argument('-m', '--use-modules', nargs='+', action=\"store\", dest=\"MODULE\", type=str,\n help=\"additional modules to use\")\n\n return parser.parse_args()","def podman(self, command: Command, **kwargs: Any) -> tmt.utils.CommandOutput:\n return self.run(Command('podman') + command, **kwargs)","def test_markdown(self):\n with sphinx_build('pyexample'):\n with open('_build/text/docfx_yaml/example.example.Foo.yml') as yml_file:\n data = yaml.safe_load(yml_file)\n for item in data['items']:\n if item['uid'] == 'example.example.Foo.method_markdown':\n self.assertEqual(\n item['summary'],\n 'Check out our '\n '[site](http://sphinx-docfx-yaml.readthedocs.io/en/latest/)'\n ' for more info.',\n )","def db_yamls(db):\n return utils.db.db_yamls(db)","def parse_misc(self,ins):\n if ins.instr == 'nop':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'syscall':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'break':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'mflo': \n if len(ins.args) == 1:\n self.gen = [ins.args[0]]\n self.need = [Register(\"$lo\")]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mtlo': \n if len(ins.args) == 1:\n self.gen = [Register(\"$lo\")]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mfhi': \n if len(ins.args) == 1:\n self.gen = [ins.args[0]]\n self.need = [Register(\"$hi\")]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mthi': \n if len(ins.args) == 1:\n self.gen = [Register(\"$hi\")]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mtc1': \n if len(ins.args) == 2:\n self.gen = [ins.args[1]]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mfc1': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.need = [ins.args[1]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'la': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.ival = ins.args[1]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'lui': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.ival = ins.args[1]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)","def test_yaml(maptype, get_obs, parse_obs):\n eq = lambda a, b: a == b\n seteq = lambda a, b: len(a) == len(b) and set(a) == set(b)\n checks = {OrdAttMap: eq, PathExAttMap: eq, AttMapEcho: eq, AttMap: seteq}\n m = make_data(ENTRIES, maptype)\n check_lines(m, EXPLINES, get_obs, parse_obs, check=checks[maptype])","def test_features(self):\n assert list(parser.generate_commands(yaml.load(\n '- my_command: {name: my_name}'))) == [('my_command', {'name': 'my_name'})]"],"string":"[\n \"def maml(self, line, cell):\\n parser = self.get_parser(CsMLMagics.maml_parser, \\\"maml\\\")\\n args = self.get_args(line, parser)\\n\\n if args is not None:\\n quiet = args.quiet\\n out, err = maml(cell, not quiet)\\n if out:\\n print(out)\\n if err:\\n print('-----')\\n print(err)\",\n \"def mlnet_parser():\\n parser = MagicCommandParser(prog=\\\"mlnet\\\",\\n description='Compiles and wrap a C# function into a Python function.\\\\n'\\n 'Automatically adds ML.net dependencies.')\\n parser.add_argument('name', type=str, help='function name')\\n parser.add_argument('-i', '--idep', nargs='*', action='append',\\n help='internal dependencies (like System, System.Linq)')\\n parser.add_argument('-d', '--dep', nargs='*', action='append',\\n help='dependencies (assembly name without extension)')\\n parser.add_argument('-c', '--catch', action='store', default=False,\\n help='catch exception')\\n return parser\",\n \"async def man(self, ctx: Context, *, command: str) -> None:\\n base_query = f\\\"https://www.mankier.com/api/v2/mans/?q={command}\\\"\\n query_url = urllib.parse.quote_plus(base_query, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n async with ctx.typing():\\n # Get API query responses\\n async with self.session.get(query_url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n results = json.loads(await response.text())[\\\"results\\\"]\\n\\n # Use first result\\n if len(results) > 0:\\n result = results[0]\\n else:\\n await ctx.send(\\\"Invalid query, no such command\\\")\\n return\\n\\n base_url = f\\\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\\\"\\n url = urllib.parse.quote_plus(base_url, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n # Load man page from first result\\n async with self.session.get(url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n result = json.loads(await response.text())\\n\\n embed = Embed(\\n title=f\\\"Man page of: **{result['name'].capitalize()}**\\\",\\n url=result[\\\"url\\\"],\\n description=f\\\"**{result['description']}** ({result['section']})\\\"\\n )\\n\\n for anchor in result['anchors']:\\n embed.add_field(\\n name=f\\\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\\\",\\n value=f\\\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\\\n[Link here]({anchor['url']})\\\",\\n inline=False\\n )\\n # TODO: Solve this with pagination\\n try:\\n await ctx.send(embed=embed)\\n except HTTPException as e:\\n if e.code == 50035:\\n await ctx.send(embed=Embed(\\n description=\\\"Body is too long to show\\\",\\n color=Color.red()\\n ))\\n else:\\n raise e\",\n \"def handle_magic(self, line, continue_prompt=None,\\n pre=None,iFun=None,theRest=None):\\n\\n cmd = '%sipmagic(\\\"%s\\\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\\n self.log(cmd,continue_prompt)\\n self.update_cache(line)\\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\\n return cmd\",\n \"def magic_lsmagic(self, parameter_s = ''):\\n print 'Available magic functions:\\\\n@'+' @'.join(self.lsmagic())\\n print '\\\\n' + Magic.auto_status[self.rc.automagic]\\n return None\",\n \"def _from_command_line():\\n # Manim can be called from the command line in three different\\n # ways. The first two involve using the manim or manimcm commands\\n prog = os.path.split(sys.argv[0])[-1]\\n from_cli_command = prog in [\\\"manim\\\", \\\"manimcm\\\"]\\n\\n # The third way involves using `python -m manim ...`. In this\\n # case, the CLI arguments passed to manim do not include 'manim',\\n # 'manimcm', or even 'python'. However, the -m flag will always\\n # be the first argument.\\n from_python_m = sys.argv[0] == \\\"-m\\\"\\n\\n return from_cli_command or from_python_m\",\n \"def parse(self, args):\\r\\n # handle `sl ...`\\r\\n main_args = self.parse_main_args(args)\\r\\n module_name = main_args['<module>']\\r\\n\\r\\n # handle `sl <module> ...`\\r\\n module_args = self.parse_module_args(module_name, main_args['<args>'])\\r\\n\\r\\n # get the command argument\\r\\n command_name = module_args.get('<command>')\\r\\n\\r\\n # handle `sl <module> <command> ...`\\r\\n return self.parse_command_args(\\r\\n module_name,\\r\\n command_name,\\r\\n main_args['<args>'])\",\n \"def magic2python(cmd):\\n\\n if cmd.startswith('#@') or cmd.startswith('@'):\\n if cmd[0]=='#':\\n cmd = cmd[1:]\\n # we need to return the proper line end later\\n if cmd[-1] == '\\\\n':\\n endl = '\\\\n'\\n else:\\n endl = ''\\n try:\\n func,args = cmd[1:].split(' ',1)\\n except:\\n func,args = cmd[1:].rstrip(),''\\n args = args.replace('\\\"','\\\\\\\\\\\"').replace(\\\"'\\\",\\\"\\\\\\\\'\\\").rstrip()\\n return '__IP.magic_%s (\\\"%s\\\")%s' % (func,args,endl)\\n else:\\n return cmd\",\n \"def magic_magic(self, parameter_s = ''):\\n\\n mode = ''\\n try:\\n if parameter_s.split()[0] == '-latex':\\n mode = 'latex'\\n except:\\n pass\\n\\n magic_docs = []\\n for fname in self.lsmagic():\\n mname = 'magic_' + fname\\n for space in (Magic,self,self.__class__):\\n try:\\n fn = space.__dict__[mname]\\n except KeyError:\\n pass\\n else:\\n break\\n magic_docs.append('@%s:\\\\n\\\\t%s\\\\n' %(fname,fn.__doc__))\\n magic_docs = ''.join(magic_docs)\\n\\n if mode == 'latex':\\n print self.format_latex(magic_docs)\\n return\\n else:\\n magic_docs = self.format_screen(magic_docs)\\n \\n outmsg = \\\"\\\"\\\"\\nIPython's 'magic' functions\\n===========================\\n\\nThe magic function system provides a series of functions which allow you to\\ncontrol the behavior of IPython itself, plus a lot of system-type\\nfeatures. All these functions are prefixed with a @ character, but parameters\\nare given without parentheses or quotes.\\n\\nExample: typing '@cd mydir' (without the quotes) changes you working directory\\nto 'mydir', if it exists.\\n\\nIf you have 'automagic' enabled (via the command line option or with the\\n@automagic function), you don't need to type in the @ explicitly.\\n\\nYou can define your own magic functions to extend the system. See the supplied\\nipythonrc and example-magic.py files for details (in your ipython\\nconfiguration directory, typically $HOME/.ipython/).\\n\\nYou can also define your own aliased names for magic functions. In your\\nipythonrc file, placing a line like:\\n\\n execute __IP.magic_cl = __IP.magic_clear\\n\\nwill define @cl as a new name for @clear.\\n\\nFor a list of the available magic functions, use @lsmagic. For a description\\nof any of them, type @magic_name?.\\n\\nCurrently the magic system has the following functions:\\\\n\\\"\\\"\\\"\\n\\n outmsg = (\\\"%s\\\\n%s\\\\n\\\\nSummary of magic functions (from @lsmagic):\\\"\\n \\\"\\\\n\\\\n@%s\\\\n\\\\n%s\\\" % (outmsg,\\n magic_docs,\\n ' @'.join(self.lsmagic()),\\n Magic.auto_status[self.rc.automagic] ) )\\n\\n page(outmsg,screen_lines=self.rc.screen_length)\",\n \"def magic_ll(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^l')\",\n \"def _parse_ml(self, line):\\n # Parse the line\\n fields = line.split('\\\\\\\\')\\n if self.lang == ENGLISH:\\n # pylint: disable=C0301\\n # English sample:\\n # 14\\\\abandonment\\\\94\\\\C\\\\\\\\1\\\\N\\\\N\\\\N\\\\N\\\\Y\\\\abandon+ment\\\\2x\\\\SA\\\\N\\\\N\\\\N\\\\#\\\\N\\\\N\\\\SA\\\\((abandon)[V],(ment)[N|V.])[N]\\\\N\\\\N\\\\N\\n # From the README:\\n # The eml.cd file contains the following fields:\\n # 1. IdNum\\n # 2. Head\\n # 3. Cob\\n # 4. MorphStatus\\n # 5. Lang\\n # 6. MorphCnt\\n # 7. NVAffComp\\n # 8. Der\\n # 9. Comp\\n # 10. DerComp\\n # 11. Def\\n # 12. Imm\\n # 13. ImmSubCat\\n # 14. ImmSA\\n # 15. ImmAllo\\n # 16. ImmSubst\\n # 17. ImmOpac\\n # 18. TransDer\\n # 19. ImmInfix\\n # 20. ImmRevers\\n # 21 FlatSA\\n # 22. StrucLab\\n # 23. StrucAllo\\n # 24. StrucSubst\\n # 25. StrucOpac\\n lemma = fields[0]\\n word = fields[1]\\n derivation = fields[21]\\n elif self.lang == DUTCH:\\n # pylint: disable=C0301\\n # Dutch sample:\\n # 19\\\\aalbessengelei\\\\7\\\\C\\\\1\\\\Y\\\\Y\\\\Y\\\\aalbes+en+gelei\\\\NxN\\\\N\\\\N\\\\(((aal)[N],(bes)[N])[N],(en)[N|N.N],(gelei)[N])[N]\\\\N\\\\N\\\\N\\n # The dml.cd file contains the following fields:\\n # 1. IdNum\\n # 2. Head\\n # 3. Inl\\n # 4. MorphStatus\\n # 5. MorphCnt\\n # 6. DerComp\\n # 7. Comp\\n # 8. Def\\n # 9. Imm\\n # 10. ImmSubCat\\n # 11. ImmAllo\\n # 12. ImmSubst\\n # 13. StrucLab\\n # 14. StruAcAllo\\n # 15. StrucSubst\\n # 16. Sepa\\n lemma = fields[0]\\n word = fields[1]\\n derivation = fields[12]\\n\\n # Skip multi-word entries for roots\\n roots = self._get_root(derivation) if \\\" \\\" not in word else None\\n return (lemma, word, roots)\",\n \"def getArbitraryManInput(self):\\n return \\\"\\\"\\\".TH MANHOLE \\\"1\\\" \\\"August 2001\\\" \\\"\\\" \\\"\\\"\\n.SH NAME\\nmanhole \\\\- Connect to a Twisted Manhole service\\n.SH SYNOPSIS\\n.B manhole\\n.SH DESCRIPTION\\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\\ncode as if at an interactive Python console inside a running Twisted process\\nwith this.\\\"\\\"\\\"\",\n \"def maml(self, maml: List[PredictionsDatapoints]):\\n\\n self._maml = maml\",\n \"def niw_mmml_mp(args):\\n return niw_mmml(*args)\",\n \"def man(command):\\n\\tspeech.speak(\\\"Executing 'man \\\" + command + \\\"' to show you documentation for this command.\\\")\\n\\tsubprocess.call([\\\"man\\\", command])\",\n \"def command(self,cmd):\\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))\",\n \"def magic(self, parameter_s=''):\\n\\n mode = ''\\n try:\\n mode = parameter_s.split()[0][1:]\\n except IndexError:\\n pass\\n\\n brief = (mode == 'brief')\\n rest = (mode == 'rest')\\n magic_docs = self._magic_docs(brief, rest)\\n\\n if mode == 'latex':\\n print(self.format_latex(magic_docs))\\n return\\n else:\\n magic_docs = format_screen(magic_docs)\\n\\n out = [\\\"\\\"\\\"\\nIPython's 'magic' functions\\n===========================\\n\\nThe magic function system provides a series of functions which allow you to\\ncontrol the behavior of IPython itself, plus a lot of system-type\\nfeatures. There are two kinds of magics, line-oriented and cell-oriented.\\n\\nLine magics are prefixed with the % character and work much like OS\\ncommand-line calls: they get as an argument the rest of the line, where\\narguments are passed without parentheses or quotes. For example, this will\\ntime the given statement::\\n\\n %timeit range(1000)\\n\\nCell magics are prefixed with a double %%, and they are functions that get as\\nan argument not only the rest of the line, but also the lines below it in a\\nseparate argument. These magics are called with two arguments: the rest of the\\ncall line and the body of the cell, consisting of the lines below the first.\\nFor example::\\n\\n %%timeit x = numpy.random.randn((100, 100))\\n numpy.linalg.svd(x)\\n\\nwill time the execution of the numpy svd routine, running the assignment of x\\nas part of the setup phase, which is not timed.\\n\\nIn a line-oriented client (the terminal or Qt console IPython), starting a new\\ninput with %% will automatically enter cell mode, and IPython will continue\\nreading input until a blank line is given. In the notebook, simply type the\\nwhole cell as one entity, but keep in mind that the %% escape can only be at\\nthe very start of the cell.\\n\\nNOTE: If you have 'automagic' enabled (via the command line option or with the\\n%automagic function), you don't need to type in the % explicitly for line\\nmagics; cell magics always require an explicit '%%' escape. By default,\\nIPython ships with automagic on, so you should only rarely need the % escape.\\n\\nExample: typing '%cd mydir' (without the quotes) changes your working directory\\nto 'mydir', if it exists.\\n\\nFor a list of the available magic functions, use %lsmagic. For a description\\nof any of them, type %magic_name?, e.g. '%cd?'.\\n\\nCurrently the magic system has the following functions:\\\"\\\"\\\",\\n magic_docs,\\n \\\"Summary of magic functions (from %slsmagic):\\\" % magic_escapes['line'],\\n str(self.lsmagic()),\\n ]\\n page.page('\\\\n'.join(out))\",\n \"def parseargs(p):\\n p.set_defaults(func=func)\\n p.description = \\\"Print machine architecture.\\\"\\n return p\",\n \"def yamlmain(argv=None):\\n if argv is None:\\n argv = sys.argv\\n if len(argv) == 1:\\n _fullusage()\\n try:\\n command = argv[1]\\n if command in ['get', 'dump']:\\n _rosparam_cmd_get_dump(command, argv)\\n elif command in ['set', 'load']:\\n _rosparam_cmd_set_load(command, argv)\\n elif command in ['delete']:\\n _rosparam_cmd_delete(argv)\\n elif command == 'list':\\n _rosparam_cmd_list(argv)\\n else:\\n _fullusage()\\n except RosParamException as e:\\n print(\\\"ERROR: \\\"+str(e), file=sys.stderr)\\n sys.exit(1)\",\n \"def arg_parse():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-m\\\", \\\"--mix\\\", required=False, help=\\\"cube shuffle\\\")\\n parser.add_argument(\\\"-e\\\", \\\"--explain\\\", action=\\\"store_true\\\", help=\\\"Get more explanation about steps\\\")\\n options = parser.parse_args()\\n return options\",\n \"def _llm_type(self) -> str:\\n return \\\"llama.cpp\\\"\",\n \"def get_ymal_load(yamlfile):\\n with open(yamlfile, 'r', encoding='utf-8') as fr:\\n filedata = fr.read()\\n yamldata = yaml.full_load(filedata)\\n return yamldata\",\n \"def _parse_args(self, cmd_line_list):\\n parser = ArgumentParser()\\n parser.add_argument('--yaml', help='yaml file specifying config to run')\\n args = parser.parse_args(cmd_line_list)\\n return vars(args)\",\n \"def _compat_parse_magic(self):\\n def warning(magic, option):\\n LOG.warning(\\\"Deprecated \\\\\\\"magic\\\\\\\" option \\\\\\\"{m}\\\\\\\" found. Please use new-style option \\\\\\\"{o}\\\\\\\" instead (see user manual).\\\".format(m=magic, o=option))\\n\\n magic_auto_backports = re.search(r\\\"\\\\*\\\\s*MINI_BUILDD:\\\\s*AUTO_BACKPORTS:\\\\s*([^*.\\\\[\\\\]]+)\\\", self._top_changes)\\n if magic_auto_backports:\\n warning(\\\"AUTO_BACKPORTS\\\", \\\"auto-ports\\\")\\n self._set(\\\"auto-ports\\\", magic_auto_backports.group(1))\\n\\n magic_backport_mode = re.search(r\\\"\\\\*\\\\s*MINI_BUILDD:\\\\s*BACKPORT_MODE\\\", self._top_changes)\\n if magic_backport_mode:\\n warning(\\\"BACKPORT_MODE\\\", \\\"ignore-lintian\\\")\\n self._set(\\\"ignore-lintian\\\", \\\"true\\\")\",\n \"def yamllint(context):\\n exec_cmd = \\\"yamllint .\\\"\\n run_cmd(context, exec_cmd)\",\n \"def parsed(self, raw):\\n if isinstance(raw, ParsedString):\\n p = raw\\n else:\\n # preparse is an overridable hook; default makes no changes\\n s = self.preparse(raw)\\n s = self.input_source_parser.transformString(s.lstrip())\\n s = self.commentGrammars.transformString(s)\\n for (shortcut, expansion) in self.shortcuts:\\n if s.lower().startswith(shortcut):\\n s = s.replace(shortcut, expansion + ' ', 1)\\n break\\n try:\\n result = self.main_parser.parseString(s)\\n except pyparsing.ParseException:\\n # If we have a parsing failure, treat it is an empty command and move to next prompt\\n result = self.main_parser.parseString('')\\n result['raw'] = raw\\n result['command'] = result.multilineCommand or result.command\\n result = self.postparse(result)\\n p = ParsedString(result.args)\\n p.parsed = result\\n p.parser = self.parsed\\n return p\",\n \"def configure_parser_motif(subparsers):\\n help_msg = \\\"Motif set (PFMs/PWMs) commands.\\\"\\n desc_msg = help_msg + dedent(\\\"\\\"\\\"\\n \\n MotifScan only detects the binding sites of known motifs. Before scanning, \\n the motif set should be installed and built with PFMs (Position Frequency \\n Matrices). Since different assemblies have different genome contents, it \\n is necessary to build the PFMs and get proper motif score cutoffs for every \\n genome assembly you want to scan later. \\n \\\"\\\"\\\")\\n\\n epilog_msg = dedent(\\\"\\\"\\\"\\n Examples:\\n --------- \\n 1) Display installed motif sets:\\n \\n motifscan motif --list\\n \\n 2) Display all available motif sets in a remote database:\\n \\n motifscan motif --list-remote\\n \\n 3) Install a motif set from a remote database and build for genome 'hg19':\\n \\n motifscan motif --install -n <motif_set> -r <remote_PFMs> -g hg19\\n \\n 4） Install a motif set with local PFMs file(s) and build for genome 'mm9':\\n\\n motifscan motif --install -n <motif_set> -i <pfms.jaspar> -g mm9\\n \\n 5) Build an installed motif set (PFMs) for additional assembly 'hg38':\\n \\n motifscan motif --build <motif_set> -g hg38\\n \\n 6) Uninstall a motif set:\\n \\n motifscan motif --uninstall <motif_set>\\n \\n Notes:\\n ------\\n 1) When installing a motif set by `--install`, you can append a `-g` option \\n to build the PFMs for the specified assembly after installation.\\n \\n 2) The genome assembly specified by `-g` should be pre-installed by command \\n `motifscan genome --install`.\\n \\n 3) The path of newly installed motif set will be automatically saved and \\n all the built PWMs files are stored under the directory. If you move it \\n to a new path, please reconfigure it:\\n \\n motifscan config --set-motif <motif_set> <new_path>\\n \\\"\\\"\\\")\\n\\n parser = subparsers.add_parser(\\n \\\"motif\\\", description=desc_msg, help=help_msg, epilog=epilog_msg,\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n subcommands = parser.add_argument_group(\\\"Motif Subcommands\\\")\\n subcommands = subcommands.add_mutually_exclusive_group()\\n subcommands.add_argument(\\n \\\"--list\\\", dest=\\\"list\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Display installed motif sets.\\\")\\n subcommands.add_argument(\\n \\\"--list-remote\\\", dest=\\\"list_remote\\\", action=\\\"store_true\\\",\\n default=False, help=\\\"Display available remote motif sets.\\\")\\n subcommands.add_argument(\\n \\\"--install\\\", dest=\\\"install\\\", action=\\\"store_true\\\", default=False,\\n help=\\\"Install a new motif set with PFMs.\\\")\\n subcommands.add_argument(\\n \\\"--build\\\", metavar=\\\"NAME\\\", dest=\\\"build\\\", default=None,\\n help=\\\"Build an installed motif set for additional genome assembly.\\\")\\n subcommands.add_argument(\\n \\\"--uninstall\\\", metavar=\\\"NAME\\\", dest=\\\"uninstall\\\",\\n help=\\\"Uninstall a motif set.\\\")\\n subcommands.required = True\\n\\n parser_install = parser.add_argument_group(\\\"Install Options\\\")\\n parser_install.add_argument(\\n \\\"-n\\\", \\\"--name\\\", metavar=\\\"NAME\\\", dest=\\\"name\\\",\\n help=\\\"Name of the motif set (PFMs) to be installed.\\\")\\n parser_install.add_argument(\\n \\\"-i\\\", metavar=\\\"FILE\\\", dest=\\\"pfm_files\\\", nargs=\\\"+\\\",\\n help=\\\"Local motif PFMs file(s) to be installed.\\\")\\n parser_install.add_argument(\\n \\\"-r\\\", \\\"--remote\\\", metavar=\\\"PFMs\\\", dest=\\\"remote\\\",\\n help=\\\"Download a remote motif PFMs set.\\\")\\n parser_install.add_argument(\\n \\\"-o\\\", \\\"--output-dir\\\", metavar=\\\"DIR\\\", dest=\\\"output_dir\\\",\\n help=\\\"Write to a given directory instead of the default directory.\\\")\\n\\n parser_remote = parser.add_argument_group(\\\"Remote Database Options\\\")\\n parser_remote.add_argument(\\n \\\"--database\\\", dest=\\\"database\\\",\\n choices=[\\\"jaspar_core\\\", \\\"jaspar_collections\\\"], default=\\\"jaspar_core\\\",\\n help=\\\"Which remote database is used to list/install motif set (PFMs). \\\"\\n \\\"Default: jaspar_core\\\")\\n\\n parser_build = parser.add_argument_group(\\\"Build Options\\\")\\n parser_build.add_argument(\\n \\\"-g\\\", \\\"--genome\\\", metavar=\\\"GENOME\\\", dest=\\\"genome\\\",\\n help=\\\"Genome assembly to build the motif set (PFMs) for.\\\")\\n parser_build.add_argument(\\n \\\"--n-random\\\", metavar=\\\"N\\\", dest=\\\"n_random\\\", type=int, default=1000000,\\n help=\\\"Generate N random background sequences to calculate motif score \\\"\\n \\\"cutoffs. Default: 1,000,000\\\")\\n parser_build.add_argument(\\n \\\"--n-repeat\\\", metavar=\\\"N\\\", dest=\\\"n_repeat\\\", type=_pos_int, default=1,\\n help=\\\"Repeat N rounds of random sampling and use the averaged cutoff \\\"\\n \\\"as final cutoff. Default: 1\\\")\\n parser_build.add_argument(\\n \\\"--max-n\\\", metavar=\\\"N\\\", dest=\\\"max_n\\\", type=int, default=0,\\n help=\\\"The maximal number of `N` base allowed in each random sampled \\\"\\n \\\"sequence. Default: 0\\\")\\n parser_build.add_argument(\\n \\\"--seed\\\", metavar=\\\"SEED\\\", dest=\\\"seed\\\", type=int, default=None,\\n help=\\\"Random seed used to generate background sequences.\\\")\\n\\n parser_threads = parser.add_argument_group(\\\"Threads Options\\\")\\n parser_threads.add_argument(\\n \\\"-t\\\", \\\"--threads\\\", metavar=\\\"N\\\", dest=\\\"n_threads\\\", type=int, default=1,\\n help=\\\"Number of processes used to run in parallel.\\\")\\n\\n parser = _add_verbose_argument(parser)\\n parser.set_defaults(func=motif.run)\",\n \"def readMaf( options, data ):\\n regex = 's\\\\s+([\\\\w\\\\d\\\\-]+?)\\\\.([\\\\w\\\\d\\\\.\\\\+\\\\-]+?)\\\\s+(\\\\d+)\\\\s+(\\\\d+)\\\\s+([-+])\\\\s+(\\\\d+)\\\\s+([\\\\-actgurykmswbdhvnACTGURYKMSWBDHVN]+)'\\n pat = re.compile( regex )\\n mf = open( options.maf )\\n mafLineList = []\\n order = -1\\n hplList = []\\n hpl = ''\\n five = ''\\n three = ''\\n for line in mf:\\n if line.startswith('#HPL'):\\n d = line.split(' ')\\n # example line: \\\"#HPL=12049 5=1 3=1 SPL=123412 S5=0 S3=12\\\"\\n # there will be one hpl line per options.other line\\n # in blocks that contain the options.ref\\n hpl = int( d[0][5:] ) # comment at start of this field\\n hFive = int( d[1][2] )\\n hThree = int( d[2][2] )\\n spl = int( d[3][4:] ) # no comment at start of this field\\n hplList.append( { 'hpl': hpl, 'hFive': hFive, \\n 'hThree': hThree, 'spl': spl } )\\n continue\\n if line.startswith('s'):\\n line = line.strip()\\n ml, order = extractMafLine( line, order, pat, options, data )\\n if ml is None:\\n sys.stderr.write( 'regexp fail on file %s line: \\\\'%s\\\\'\\\\n'\\n 'Regex: \\\\'%s\\\\'\\\\n' % ( options.maf, line, regex ) )\\n sys.exit( 1 )\\n if ml == 'notOurGenome':\\n continue\\n if ml.length != len( ml.sequence ):\\n sys.stderr.write( 'Error while working on file %s :\\\\n '\\n 'printed sequence length (%d) not equal to actual sequence '\\n 'length (%d) ref genome:%s other genome:%s line below:\\\\n%s\\\\n' % \\n ( options.maf, ml.length, len( ml.sequence ), options.ref, options.other, line ) )\\n sys.exit( 1 )\\n mafLineList.append( ml )\\n else:\\n # end of the block\\n if len( mafLineList ) > 0:\\n extractBlockPairs( mafLineList, hplList, options, data )\\n mafLineList = []\\n order = -1\\n hplList = []\\n hpl = ''\\n five = ''\\n three = ''\\n if len( mafLineList ) > 0:\\n extractBlockPairs( mafLineList, hplList, options, data )\",\n \"def set_m(self, varname: str, varval: Optional[str]) -> None:\\n if varname:\\n self.pandoc.append('-M')\\n self.pandoc.append(f'{varname}={varval}')\",\n \"def run_man(self, expanded, unexpanded) : \\n\\t\\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\\n\\t\\tif not unexpanded :\\n\\t\\t\\tunexpanded = methodslist\\n\\t\\tunexpanded.sort()\\n\\n\\t\\tresults = []\\n\\t\\tfor method in unexpanded :\\n\\t\\t\\tif results :\\n\\t\\t\\t\\t# more than one command to display help for\\n\\t\\t\\t\\t# so we separate them in the plain text output\\n\\t\\t\\t\\tself.printf(\\\"\\\\n--------\\\\n\\\\n\\\")\\n\\t\\t\\tif not hasattr(self, 'run_' + method) :\\n\\t\\t\\t\\thelp = helphtml = \\\"Invalid command\\\"\\n\\t\\t\\telse :\\n\\t\\t\\t\\thelp = getattr(self, 'run_' + method).__doc__\\n\\t\\t\\t\\tif not help :\\n\\t\\t\\t\\t\\thelp = helphtml = \\\"Undocumented command\\\"\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\thelplines = map(string.strip, string.split(help, '\\\\n'))\\n\\t\\t\\t\\t\\thelp = string.join(helplines, '\\\\n')\\n\\t\\t\\t\\t\\thelphtml = string.join(helplines, '<br />')\\n\\t\\t\\tcommand = '<a href=\\\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\\\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\\n\\t\\t\\tresults.append({\\\"Command\\\": command, \\\"Help\\\": helphtml})\\n\\t\\t\\tself.printf(\\\"%s: %s\\\\n\\\" % (method, help))\\n\\t\\tself.tableDisplay(\\\"man\\\", [\\\"Command\\\", \\\"Help\\\"], results)\",\n \"def _parse_args(marbl_root):\\n\\n import argparse\\n import os\\n\\n parser = argparse.ArgumentParser(description=\\\"Convert MARBL's YAML files to JSON\\\",\\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\\n\\n parser.add_argument('-s', '--settings_file', action='store', dest='settings_file',\\n default=os.path.join(marbl_root, 'src', 'default_settings.yaml'),\\n help='Location of YAML-formatted MARBL settings file to convert to JSON')\\n\\n parser.add_argument('-d', '--diags_file', action='store', dest='diags_file',\\n default=os.path.join(marbl_root, 'src', 'default_diagnostics.yaml'),\\n help='Location of YAML-formatted MARBL diagnostics file to convert to JSON')\\n\\n parser.add_argument('-o', '--output_dir', action='store', dest='output_dir',\\n default=os.path.join(marbl_root, 'autogenerated_src'),\\n help=\\\"Directory where JSON file(s) will be created\\\")\\n\\n return parser.parse_args()\",\n \"def main(raw_args):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--module-link')\\n parser.add_argument('module_path', type=os.path.realpath)\\n args = parser.parse_args(raw_args)\\n\\n return md_module(\\n load_module_from_path(args.module_path), module_link=args.module_link)\",\n \"def Parse(self, attribute_to_args_map, base_fallthroughs_map,\\n parsed_args=None, plural=False, allow_empty=False):\\n raise NotImplementedError\",\n \"def magic_ld(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep /$')\",\n \"def mfa_cli(ctx: click.Context) -> None:\\n from montreal_forced_aligner.command_line.utils import check_server, start_server, stop_server\\n\\n config.load_configuration()\\n auto_server = False\\n run_check = True\\n if ctx.invoked_subcommand == \\\"anchor\\\":\\n config.CLEAN = False\\n config.USE_POSTGRES = True\\n config.CLEAN = False\\n config.USE_POSTGRES = True\\n if \\\"--help\\\" in sys.argv or ctx.invoked_subcommand in [\\n \\\"configure\\\",\\n \\\"version\\\",\\n \\\"history\\\",\\n \\\"server\\\",\\n \\\"align_one\\\",\\n ]:\\n auto_server = False\\n run_check = False\\n elif ctx.invoked_subcommand in [\\\"model\\\", \\\"models\\\"]:\\n if \\\"add_words\\\" in sys.argv or \\\"inspect\\\" in sys.argv:\\n config.CLEAN = True\\n config.USE_POSTGRES = False\\n else:\\n run_check = False\\n elif ctx.invoked_subcommand == \\\"g2p\\\":\\n if len(sys.argv) > 2 and sys.argv[2] == \\\"-\\\":\\n run_check = False\\n auto_server = False\\n else:\\n auto_server = config.AUTO_SERVER\\n if \\\"--no_use_postgres\\\" in sys.argv or not config.USE_POSTGRES:\\n run_check = False\\n auto_server = False\\n if auto_server:\\n start_server()\\n elif run_check:\\n check_server()\\n warnings.simplefilter(\\\"ignore\\\")\\n check_third_party()\\n if ctx.invoked_subcommand != \\\"anchor\\\":\\n hooks = ExitHooks()\\n hooks.hook()\\n atexit.register(hooks.history_save_handler)\\n if auto_server:\\n atexit.register(stop_server)\",\n \"async def manga(self, ctx: commands.Context) -> None:\\n if ctx.invoked_subcommand is None:\\n if ctx.subcommand_passed is None:\\n # There is no subcommand: inform the user about the manga reader.\\n summary = \\\"\\\"\\\"Hi! Welcome to Bakerbot's manga reader.\\n This cog houses commands for searching and reading manga.\\n See `$help mangadex` for a full list of available subcommands.\\\"\\\"\\\"\\n\\n embed = utilities.Embeds.standard()\\n embed.set_footer(text=\\\"Powered by the Mangadex API.\\\", icon_url=utilities.Icons.info)\\n embed.description = summary\\n await ctx.reply(embed=embed)\\n else:\\n # The subcommand was not valid: throw a fit.\\n command = f\\\"${ctx.command.name} {ctx.subcommand_passed}\\\"\\n summary = f\\\"`{command}` is not a valid command.\\\"\\n footer = \\\"Try $help mangadex for a full list of available subcommands.\\\"\\n embed = utilities.Embeds.status(False, summary)\\n embed.set_footer(text=footer, icon_url=utilities.Icons.cross)\\n await ctx.reply(embed=embed)\",\n \"def parsingcommands(self):\\n parser = argparse.ArgumentParser(\\n description=\\\"httpfs is a simple file server.\\\")\\n parser.add_argument(\\\"-v\\\", action=\\\"store_true\\\", dest=\\\"debug\\\",\\n help=\\\"Prints debugging messages.\\\", default=False)\\n parser.add_argument(\\\"-p\\\", action=\\\"store\\\", dest=\\\"port\\\",\\n help=\\\"Specifies the port number that the server will listen and serve at. Default is 8080.\\\",\\n type=int, default=8080)\\n parser.add_argument(\\\"-d\\\", action=\\\"store\\\", dest=\\\"path_to_dir\\\",\\n help=\\\"Specifies the directory that the server will use to read/writerequested files. \\\\\\n Default is the current directory when launching theapplication.\\\",\\n default='./')\\n parser.add_argument(\\\"-arq\\\", action='store_true', dest=\\\"arq\\\", default=False, help=\\\"Automatic-Repeat-Request (ARQ)\\\")\\n\\n return parser.parse_args()\",\n \"def command(self, cmd):\\n self.lmp.command(cmd)\",\n \"def parse_cmd(cmd):\\n begin_pat = re.compile(r'BEGIN\\\\s*\\\\{(.+?)\\\\}\\\\s*;?', re.X | re.S)\\n end_pat = re.compile(r'END\\\\s*\\\\{(.+?)\\\\}\\\\s*;?', re.X | re.S)\\n normal_pat = re.compile(r'([^{]*)(\\\\{(.+?)\\\\})?\\\\s*;?', re.X | re.S)\\n\\n # get BEGIN part\\n begin = u''\\n m = begin_pat.search(cmd)\\n if m:\\n begin = m.group(1).strip()\\n cmd = cmd.replace(m.group(0), u'')\\n\\n # get END part\\n end = u''\\n m = end_pat.search(cmd)\\n if m:\\n end = m.group(1).strip()\\n cmd = cmd.replace(m.group(0), u'')\\n\\n # get NORMAL part\\n normal = (u'', u'')\\n m = normal_pat.search(cmd)\\n if m:\\n pattern = m.group(1) or u'' # get u'' if \\\\1 is None\\n action = m.group(3) or u'' # get u'' if \\\\3 is None\\n normal = (pattern.strip(), action.strip())\\n\\n return (begin, normal, end)\",\n \"def __getattr__(self, item):\\n if item not in _CommandsMetaClass.commands_dict:\\n raise MPDCommandNotExists(\\\"no such command: '{}'\\\".format(item))\\n\\n f = lambda *args: \\\"{} {}\\\\n\\\".format(item, ' '.join(_CommandsMetaClass._quote_arguments(args)))\\n f.__doc__ = \\\"Command's Arguments: {}\\\".format(_CommandsMetaClass.commands_dict[item])\\n f.__name__ = item\\n return f\",\n \"def get_cmd():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", action=\\\"store\\\", dest=\\\"inputfile\\\", help=\\\"file with multiple hmm models\\\")\\n parser.add_argument(\\\"-o\\\", action=\\\"store\\\", dest=\\\"dirout\\\", help=\\\"directory to store separated hmm models\\\")\\n params = parser.parse_args()\\n return params\",\n \"def configure_parser_main():\\n description = dedent(\\\"\\\"\\\"\\n MotifScan: A motif discovery tool to detect the occurrences of known motifs\\n \\n Given a set of input genomic regions, MotifScan scans the sequences to \\n detect the occurrences of known motifs. It can also perform an enrichment \\n analysis to check whether these motifs are over/under-represented compared \\n to the control regions.\\n \\n !!! NOTE !!!\\n MotifScan requires basic data files including genome sequences and motif \\n PFMs (Position Frequency Matrices) to detect the binding sites of motifs. \\n Before scanning, users should install genome assemblies and motif sets from\\n a remote database or with local prepared files via `motifscan genome` and \\n `motifscan motif` subcommands.\\n \\n Citation:\\n Sun, H., Wang, J., Gong, Z. et al. Quantitative integration of epigenomic \\n variation and transcription factor binding using MAmotif toolkit identifies\\n an important role of IRF2 as transcription activator at gene promoters. \\n Cell Discov 4, 38 (2018). https://doi.org/10.1038/s41421-018-0045-y\\n \\\"\\\"\\\")\\n\\n epilog_msg = dedent(\\\"\\\"\\\"\\n Please run `motifscan COMMAND -h` to see the subcommand options.\\n \\n See also: \\n Documentation: https://motifscan.readthedocs.io\\n Source code: https://github.com/shao-lab/MotifScan\\n Bug reports: https://github.com/shao-lab/MotifScan/issues\\n \\\"\\\"\\\")\\n\\n parser = argparse.ArgumentParser(\\n description=description, epilog=epilog_msg,\\n formatter_class=argparse.RawDescriptionHelpFormatter)\\n parser.add_argument(\\\"-v\\\", \\\"--version\\\", action=\\\"version\\\",\\n version=f\\\"MotifScan {__version__}\\\")\\n\\n subparsers = parser.add_subparsers(title=\\\"MotifScan Subcommands\\\",\\n metavar=\\\"command\\\", dest=\\\"cmd\\\")\\n configure_parser_config(subparsers)\\n configure_parser_genome(subparsers)\\n configure_parser_motif(subparsers)\\n configure_parser_scan(subparsers)\\n return parser\",\n \"def lemma(self) -> str:\",\n \"def cmd_mdtm(args):\",\n \"def magic_r(self, parameter_s=''):\\n\\n start = parameter_s.strip()\\n # Identify magic commands even if automagic is on (which means\\n # the in-memory version is different from that typed by the user).\\n if self.shell.rc.automagic:\\n start_magic = '@'+start\\n else:\\n start_magic = start\\n # Look through the input history in reverse\\n for n in range(len(self.shell.input_hist)-2,0,-1):\\n input = self.shell.input_hist[n]\\n if input.startswith('#@'):\\n input = input[1:]\\n if input != '@r\\\\n' and \\\\\\n (input.startswith(start) or input.startswith(start_magic)):\\n #print 'match',`input` # dbg\\n if input.startswith('@'):\\n input = magic2python(input)\\n #print 'modified',`input` # dbg\\n print 'Executing:',input,\\n exec input in self.shell.user_ns\\n return\\n print 'No previous input matching `%s` found.' % start\",\n \"def __init__(self,cmds):\\n\\n # Since the list may include multi-line entries, first make sure that\\n # they've been all broken up before passing it to magic2python\\n cmdlist = map(magic2python,''.join(cmds).split('\\\\n'))\\n self.value = '\\\\n'.join(cmdlist)\",\n \"def _magic_docs(self, brief=False, rest=False):\\n mman = self.shell.magics_manager\\n docs = mman.lsmagic_docs(brief, missing='No documentation')\\n\\n if rest:\\n format_string = '**%s%s**::\\\\n\\\\n%s\\\\n\\\\n'\\n else:\\n format_string = '%s%s:\\\\n%s\\\\n'\\n\\n return ''.join(\\n [format_string % (magic_escapes['line'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['line'].items())]\\n +\\n [format_string % (magic_escapes['cell'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['cell'].items())]\\n )\",\n \"def magic_alias(self, parameter_s = ''):\\n\\n par = parameter_s.strip()\\n if not par:\\n if self.rc.automagic:\\n prechar = ''\\n else:\\n prechar = '@'\\n print 'Alias\\\\t\\\\tSystem Command\\\\n'+'-'*30\\n aliases = self.alias_table.keys()\\n aliases.sort()\\n for alias in aliases:\\n print prechar+alias+'\\\\t\\\\t'+self.alias_table[alias]\\n return\\n try:\\n alias,cmd = par.split(' ',1)\\n except:\\n print inspect.getdoc(self.magic_alias)\\n return\\n nargs = cmd.count('%s')\\n if nargs == 0: # simple aliases\\n fndef = itpl(\\n\\\"\\\"\\\"\\ndef magic_${alias}(parameter_s = ''):\\n '''Alias to the system command '$cmd' '''\\n xsys('$cmd '+str(parameter_s))\\n\\nself.magic_$alias = magic_$alias\\n\\\"\\\"\\\")\\n else: # parametric aliases\\n fndef = itpl(\\n\\\"\\\"\\\"\\ndef magic_${alias}(parameter_s = ''):\\n '''Alias to the system command '$cmd' '''\\n cmd = '$cmd'\\n nargs = cmd.count('%s')\\n args = str(parameter_s).split()\\n\\n if len(args) != nargs:\\n print 'Incorrect number of arguments:',nargs,'expected.'\\n print \\\"$alias is an alias to: '$cmd'\\\"\\n return\\n else:\\n cmd_call = cmd % tuple(args)\\n xsys(cmd_call)\\n\\nself.magic_$alias = magic_$alias\\n\\\"\\\"\\\")\\n try:\\n exec fndef in globals(),locals()\\n except:\\n print self.magic_alias.__doc__\\n self.alias_table.update({alias:cmd})\",\n \"def parse_args(default_minppmm=1000):\\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\\n parser.add_argument(\\\"-p\\\", \\\"--plumedir\\\", required=True,\\n help=\\\"path to input plume file directory\\\")\\n parser.add_argument(\\\"-r\\\", \\\"--regex\\\", required=False,\\n default=\\\"ang.*_detections/ime_minppmm{}/ang.*_ime_minppmm{}.*\\\".format(\\n default_minppmm, default_minppmm),\\n help=\\\"Regular expression to match for plume files\\\")\\n parser.add_argument(\\\"-w\\\", \\\"--windir\\\", required=True,\\n help=\\\"path to input wind file directory\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--outfile\\\", required=True,\\n help=\\\"path to output plume list\\\")\\n parser.add_argument(\\\"-f\\\", \\\"--force\\\",\\n help=\\\"Force reprocessing of all files (not just the new ones)\\\",\\n action='store_true')\\n parser.add_argument(\\\"-n\\\", \\\"--nprocs\\\", type=int, default=1,\\n help=\\\"number of parallel processes to use; default=1 (sequential)\\\")\\n parser.add_argument(\\\"--flmode\\\",\\n help=\\\"Executes script in flightline mode, running on a single flightline\\\",\\n action=\\\"store_true\\\")\\n args = parser.parse_args()\\n return (args.plumedir, args.regex, args.windir, args.outfile,\\n args.force, args.nprocs, args.flmode)\",\n \"def get_input_pattern():\\n return '-palign'\",\n \"def list_param(command):\\n namespace = app.main(command)\\n assert namespace.command == 'lp' or namespace.command == \\\"listparam\\\"\",\n \"def _parser(s, remainder):\\n parser = _ArgumentParser()\\n def run():\\n return s.parse(parser, remainder)\\n parser.run = run\\n return parser\",\n \"def _make_matlab_command(self):\\n \\n raise NotImplementedError\",\n \"def setup_parser(self):\\n parser = argparse.ArgumentParser(description=DESCRIPTION)\\n parser.add_argument('words', metavar='W', nargs='+', help=POSITIONAL_HELP)\\n parser.add_argument('-a','--any', dest=\\\"search_funct\\\", action=\\\"store_const\\\", \\n const='any', default='all', help=SEARCH_HELP)\\n parser.add_argument('-o','--only-id', action='store_true', help=ID_HELP)\\n parser.add_argument('-u', '--update', action='store_true', help=UPDATE_HELP)\\n return parser\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"CUDAPOA Python API sample program.\\\")\\n parser.add_argument('-m',\\n help=\\\"Run MSA generation. By default consensusis generated.\\\",\\n action='store_true')\\n parser.add_argument('-p',\\n help=\\\"Print output MSA or consensus for each POA group.\\\",\\n action='store_true')\\n parser.add_argument('-l',\\n help=\\\"Use long or short read sample data.\\\",\\n action='store_true')\\n return parser.parse_args()\",\n \"def test_lspci_mmv_ubuntu_20_10(self):\\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_mmv'], quiet=True),\\n self.f_json['ubuntu_20_10_lspci_mmv'])\",\n \"def test_macro(self):\\n env = create_env()\\n pkg = create_manifest(\\\"mock\\\")\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test)\\n cmd2()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([], result)\\n\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test)\\n if()\\n cmd()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([\\\"INDENTATION\\\"], result)\\n\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test2)\\n cmd()\\n endmacro()\\n macro(test)\\n if()\\n cmd()\\n test2()\\n cmd()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([], result)\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test4)\\n cmd()\\n if()\\n cmd()\\n endif()\\n endmacro()\\n macro(test3)\\n test4()\\n endmacro()\\n macro(test2)\\n test3()\\n if()\\n if()\\n if()\\n cmd()\\n test3()\\n endif()\\n endif()\\n endif()\\n endmacro()\\n macro(test)\\n test2()\\n if()\\n cmd()\\n test2()\\n else()\\n foreach(a b c d e)\\n test2()\\n endforeach()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\",\n \"def parse(self, commands):\\n raise NotImplementedError()\",\n \"def lsmagic(self, parameter_s=''):\\n return MagicsDisplay(self.shell.magics_manager, ignore=[])\",\n \"def run(md_file, interact):\\n lines = open(md_file, 'r').readlines()\\n blocks = extract_blocks(lines)\\n run_py(blocks, interact=interact)\",\n \"def runMainParser(cmd):\\r\\n\\r\\n global local_vars\\r\\n local_vars={}\\r\\n # pre-process phrase to group keyword sequences\\r\\n cmd = hyphenate(cmd)\\r\\n cmd = pluralize(cmd)\\r\\n # bitpar\\r\\n cmd = subprocess.check_output(\\\"sh ../bitpar/parse '\\\"+cmd+\\\"'\\\",shell=True)\\r\\n cmd = re.sub('\\\\n','',cmd)\\r\\n cmd = label(cmd)\\r\\n print 'syntax: '+cmd\\r\\n # update input.txt\\r\\n subprocess.call(\\\"cp ../lambda/lambda-defs.txt ../lambda/input.txt\\\",shell=True)\\r\\n subprocess.call(\\\"echo '\\\"+cmd+\\\"' >> ../lambda/input.txt\\\",shell=True)\\r\\n # lambda calculator & plop\\r\\n subprocess.call(\\\"java -jar ../lambda/HCI-auto.jar ../lambda/input.txt > ../lambda/input.tex\\\",shell=True)\\r\\n subprocess.call(\\\"make -C ../lambda input.fml\\\",shell=True)\\r\\n fml = subprocess.check_output('cat ../lambda/input.fml',shell=True)[:-1]\\r\\n if fml == '' or fml == ' {result \\\\\\\\ $tt$ \\\\\\\\': raise ParseError(cmd+' cannot be interpreted by lambda calculator')\\r\\n lambdaCalc_output=fml.split('true ')[1][:-2]\\r\\n #lambda_output_history.append(lambdaCalc_output) #out of scope. how do i fix this?\\r\\n #lambda_output_history was never initialized\\r\\n print 'logic: '+lambdaCalc_output\\r\\n parse(lambdaCalc_output)\",\n \"def usage():\\n print \\\"\\\"\\\"\\nUsages:\\n ./lmf-merger.py -m file1 file2 outfile\\n ./lmf-merger.py -s file1 ...\\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\\\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\\n \\\"\\\"\\\"\",\n \"def libmagic(self):\\n return self.tag(\\\"libmagic\\\")\",\n \"def get_args():\\n parser = argparse.ArgumentParser(\\n description=\\\"\\\"\\\"summary.py\\\"\\\"\\\")\\n parser.add_argument(\\n \\\"--maf\\\",\\n required=True,\\n default=None,\\n help=\\\"\\\"\\\"The path to the directory containing maf file(s)\\\"\\\"\\\"\\n )\\n parser.add_argument(\\n \\\"--db\\\",\\n required=True,\\n default=None,\\n help=\\\"\\\"\\\"The name of the output SQLITE database to hold results\\\"\\\"\\\"\\n )\\n parser.add_argument(\\n \\\"--metadata-key\\\",\\n required=True,\\n dest=\\\"metadata\\\",\\n type=str,\\n help=\\\"\\\"\\\"The primary species in the alignment (e.g. the one on top in the MAF file)\\\"\\\"\\\"\\n )\\n parser.add_argument(\\n \\\"--alignment-length\\\",\\n dest=\\\"align\\\",\\n type=int,\\n default=25,\\n help=\\\"\\\"\\\"The minimum acceptable alignment length\\\"\\\"\\\"\\n )\\n parser.add_argument(\\n \\\"--consensus-length\\\",\\n dest=\\\"consensus\\\",\\n type=int,\\n default=25,\\n help=\\\"\\\"\\\"The minimum acceptable consensus length\\\"\\\"\\\"\\n )\\n return parser.parse_args()\",\n \"def apms(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ApmReferenceArgs']]]]:\\n return pulumi.get(self, \\\"apms\\\")\",\n \"def magic_lf(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^-')\",\n \"def arg_parse():\\n p = ap.ArgumentParser()\\n p.add_argument()\\n return p.parse_args()\",\n \"def parse_lines(lines, packages):\\n for line in lines:\\n x = line.split(' ')\\n cmd = x[0].upper()\\n #LOG.debug(cmd)\\n if 'LIST' in cmd:\\n getattr(commands, cmd)(p)\\n else:\\n getattr(commands, cmd)(line, p)\",\n \"def saml_args(subparsers: argparse.ArgumentParser) -> argparse.ArgumentParser:\\n example_usage = \\\"\\\"\\\"example usage:\\n\\n ticketsplease saml --adfs-config '...' --target-user-guid '...' --dkm-key '...' --assertion\\n ticketsplease saml --adfs-config-file config.bin --domain company.com --target-user tUser --domain-username user --domain-password password --dc-ip 10.10.10.10\\n \\\"\\\"\\\"\\n\\n saml_parser = subparsers.add_parser(\\n \\\"saml\\\",\\n description=\\\"Generate a Golden SAML token\\\",\\n epilog=example_usage,\\n formatter_class=argparse.RawDescriptionHelpFormatter,\\n )\\n saml_parser.add_argument(\\n \\\"--adfs-config\\\",\\n type=str,\\n help=\\\"ADFS configuration settings.\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--adfs-config-file\\\",\\n type=str,\\n help=\\\"File containing the ADFS configuration settings.\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--domain\\\",\\n type=str,\\n help=\\\"Target domain the Golden SAML token is generated for (i.e. company.com).\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--target-user\\\",\\n type=str,\\n help=\\\"Username of the account to generate the Golden SAML token for.\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--target-user-upn\\\",\\n type=str,\\n help=\\\"UPN of the account to generate the Golden SAML token for (if not provided, retrieved via LDAP).\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--target-user-guid\\\",\\n type=str,\\n help=\\\"GUID of the account to generate the Golden SAML token for (if not provided, retrieved via LDAP).\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--dkm-key\\\",\\n type=str,\\n help=\\\"DKM Key (if not provided, retrieved via LDAP).\\\",\\n )\\n saml_parser.add_argument(\\n \\\"--assertion\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Extract the SAML Assertion from the token.\\\",\\n )\\n # LDAP/WMIC options\\n domain_saml_options = saml_parser.add_argument_group(\\\"ldap/wmic arguments\\\")\\n domain_saml_options.add_argument(\\n \\\"--domain-username\\\",\\n type=str,\\n help=\\\"Username to perform LDAP/WMIC operations with.\\\",\\n )\\n domain_saml_options.add_argument(\\n \\\"--domain-password\\\",\\n type=str,\\n help=\\\"Password of the account to perform LDAP/WMIC operations with.\\\",\\n )\\n domain_saml_options.add_argument(\\n \\\"--dc-ip\\\",\\n type=str,\\n help=\\\"IP address of the target Domain Controller.\\\",\\n )\\n\\n return saml_parser\",\n \"def _register_commands(self):\\n cmds = []\\n cmd_help = CommandParser(\\\"help\\\", \\\"Show help for a command.\\\")\\n cmd_help.add_argument(\\n \\\"command\\\",\\n nargs=\\\"*\\\",\\n help=\\\"The command to get help for. Specify multiple names to get help for subcommands.\\\",\\n )\\n cmd_help.add_argument(\\\"-m\\\", \\\"--module\\\", help=\\\"List all commands from the given module\\\")\\n cmd_help.add_argument(\\n \\\"-f\\\",\\n \\\"--full\\\",\\n action=\\\"store_true\\\",\\n help='Include descriptions in the \\\"all\\\" help output.',\\n )\\n cmds.append(cmd_help)\\n\\n target_mod = CommandParser()\\n target_mod.add_argument(\\\"module\\\", nargs=\\\"+\\\", help=\\\"Target module(s)\\\")\\n target_mod.add_argument(\\n \\\"-p\\\",\\n \\\"--protocol\\\",\\n action=\\\"store_const\\\",\\n const=\\\"protocol\\\",\\n default=\\\"feature\\\",\\n dest=\\\"mtype\\\",\\n help=\\\"Target is a protocol module\\\",\\n )\\n cmd_module = CommandParser(\\\"module\\\", \\\"Manage and query ZeroBot modules\\\")\\n add_subcmd = cmd_module.make_adder(metavar=\\\"OPERATION\\\", dest=\\\"subcmd\\\", required=True)\\n add_subcmd(\\\"load\\\", description=\\\"Load a module\\\", parents=[target_mod])\\n add_subcmd(\\\"reload\\\", description=\\\"Reload a module\\\", parents=[target_mod])\\n subcmd_list = add_subcmd(\\\"list\\\", description=\\\"List available modules\\\")\\n subcmd_list.add_argument(\\\"-l\\\", \\\"--loaded\\\", action=\\\"store_true\\\", help=\\\"Only loaded modules\\\")\\n list_group = subcmd_list.add_mutually_exclusive_group()\\n default_categories = [\\\"protocol\\\", \\\"feature\\\"]\\n list_group.add_argument(\\n \\\"-f\\\",\\n \\\"--feature\\\",\\n action=\\\"store_const\\\",\\n const=[\\\"feature\\\"],\\n dest=\\\"category\\\",\\n default=default_categories,\\n help=\\\"Only feature modules\\\",\\n )\\n list_group.add_argument(\\n \\\"-p\\\",\\n \\\"--protocol\\\",\\n action=\\\"store_const\\\",\\n const=[\\\"protocol\\\"],\\n dest=\\\"category\\\",\\n default=default_categories,\\n help=\\\"Only protocol modules\\\",\\n )\\n add_subcmd(\\\"info\\\", description=\\\"Show module information\\\", parents=[target_mod])\\n cmds.append(cmd_module)\\n\\n save_reload_args = CommandParser()\\n save_reload_args.add_argument(\\n \\\"config_file\\\",\\n nargs=\\\"*\\\",\\n help=\\\"Name of config file (without .toml extension). Omit to affect all loaded config files.\\\",\\n )\\n set_reset_args = CommandParser()\\n set_reset_args.add_argument(\\\"config_file\\\", help=\\\"Name of config file (without .toml extension)\\\")\\n cmd_config = CommandParser(\\\"config\\\", \\\"Manage configuration\\\")\\n add_subcmd = cmd_config.make_adder(metavar=\\\"OPERATION\\\", dest=\\\"subcmd\\\", required=True)\\n add_subcmd(\\\"save\\\", description=\\\"Save config files to disk\\\", parents=[save_reload_args])\\n subcmd_savenew = add_subcmd(\\\"savenew\\\", description=\\\"Save config file to a new path\\\")\\n subcmd_savenew.add_argument(\\\"config_file\\\", help=\\\"Name of config file (without .toml extension)\\\")\\n subcmd_savenew.add_argument(\\\"new_path\\\", help=\\\"The path to save the config file to\\\")\\n add_subcmd(\\n \\\"reload\\\",\\n description=\\\"Reload config files from disk\\\",\\n parents=[save_reload_args],\\n )\\n subcmd_set = add_subcmd(\\\"set\\\", description=\\\"Modify config settings\\\", parents=[set_reset_args])\\n subcmd_set.add_argument(\\n \\\"key_path\\\",\\n help=\\\"The config key to set. Subkeys are separated by dots, e.g. 'Core.Backup.Filename'\\\",\\n )\\n subcmd_set.add_argument(\\\"value\\\", nargs=\\\"?\\\", help=\\\"The new value. Omit to show the current value.\\\")\\n subcmd_reset = add_subcmd(\\n \\\"reset\\\",\\n description=\\\"Reset config settings to last loaded value\\\",\\n parents=[set_reset_args],\\n )\\n subcmd_reset.add_argument(\\n \\\"key_path\\\",\\n nargs=\\\"?\\\",\\n help=(\\n \\\"The config key to set. Subkeys are separated by dots, \\\"\\n \\\"e.g. 'Core.Backup.Filename'. If omitted, the entire \\\"\\n \\\"config will be reset.\\\"\\n ),\\n )\\n subcmd_reset.add_argument(\\n \\\"-d\\\",\\n \\\"--default\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Set the key to its default value instead. Effectively unsets a config key.\\\",\\n )\\n cmds.append(cmd_config)\\n\\n cmd_version = CommandParser(\\\"version\\\", \\\"Show version information\\\")\\n cmds.append(cmd_version)\\n\\n cmd_restart = CommandParser(\\\"restart\\\", \\\"Restart ZeroBot.\\\")\\n cmd_restart.add_argument(\\\"msg\\\", nargs=\\\"*\\\", help=\\\"Message sent to protocol modules as a reason\\\")\\n cmds.append(cmd_restart)\\n\\n cmd_quit = CommandParser(\\\"quit\\\", \\\"Shut down ZeroBot.\\\")\\n cmd_quit.add_argument(\\\"msg\\\", nargs=\\\"*\\\", help=\\\"Message sent to protocol modules as a reason\\\")\\n cmds.append(cmd_quit)\\n\\n cmd_wait = CommandParser(\\\"wait\\\", \\\"Execute a command after a delay\\\")\\n cmd_wait.add_argument(\\n \\\"delay\\\",\\n help=\\\"Amount of time to delay. Accepts the following modifier suffixes: 'ms', 's' (default), 'm', 'h'.\\\",\\n )\\n cmd_wait.add_argument(\\\"command\\\", help=\\\"Command to delay\\\")\\n cmd_wait.add_argument(\\\"args\\\", nargs=argparse.REMAINDER, help=\\\"Command arguments\\\")\\n cmds.append(cmd_wait)\\n\\n cmd_cancel = CommandParser(\\\"cancel\\\", \\\"Cancel a waiting command\\\")\\n cancel_group = cmd_cancel.add_mutually_exclusive_group()\\n cancel_group.add_argument(\\\"id\\\", type=int, nargs=\\\"?\\\", help=\\\"The ID of a waiting command\\\")\\n cancel_group.add_argument(\\\"-l\\\", \\\"--list\\\", action=\\\"store_true\\\", help=\\\"List currently waiting commands\\\")\\n cmds.append(cmd_cancel)\\n\\n cmd_backup = CommandParser(\\\"backup\\\", \\\"Create a database backup\\\")\\n cmd_backup.add_argument(\\\"name\\\", type=Path, help=\\\"Backup filename\\\")\\n cmds.append(cmd_backup)\\n\\n self.command_register(\\\"core\\\", *cmds)\",\n \"def parsemeta(metalines):\\n def parseline(line):\\n res = [val.strip() for val in line[5:].split(u':', 1)]\\n key, value = (res[0], res[1]) if len(res) == 2 else (res[0], u'')\\n if re.match(r'^-?\\\\d*[\\\\.|,]?\\\\d+$', value):\\n value = float(value)\\n elif re.match(r'^\\\\[(.*)\\\\]', value):\\n value = [val.strip() for val in value[1:-1].split(u',')]\\n value = [float(val) if re.match(r'^-?\\\\d*[\\\\.|,]?\\\\d+$', val) else val for val in value]\\n return key, value\\n return OrderedDict(parseline(line) for line in metalines if line.startswith(u'#CTE_'))\",\n \"def runMainParser(cmd):\\n\\n global local_vars\\n local_vars={}\\n # pre-process phrase to group keyword sequences\\n cmd = hyphenate(cmd)\\n cmd = pluralize(cmd)\\n # bitpar\\n cmd = subprocess.check_output(\\\"sh ../bitpar/parse '\\\"+cmd+\\\"'\\\",shell=True)\\n cmd = re.sub('\\\\n','',cmd)\\n cmd = label(cmd)\\n print 'syntax: '+cmd\\n # update input.txt\\n subprocess.call(\\\"cp ../lambda/lambda-defs.txt ../lambda/input.txt\\\",shell=True)\\n subprocess.call(\\\"echo '\\\"+cmd+\\\"' >> ../lambda/input.txt\\\",shell=True)\\n # lambda calculator & plop\\n subprocess.call(\\\"java -jar ../lambda/HCI-auto.jar ../lambda/input.txt > ../lambda/input.tex\\\",shell=True)\\n subprocess.call(\\\"make -C ../lambda input.fml\\\",shell=True)\\n fml = subprocess.check_output('cat ../lambda/input.fml',shell=True)[:-1]\\n if fml == '' or fml == ' {result \\\\\\\\ $tt$ \\\\\\\\': raise ParseError(cmd+' cannot be interpreted by lambda calculator')\\n lambdaCalc_output=fml.split('true ')[1][:-2]\\n #lambda_output_history.append(lambdaCalc_output) #out of scope. how do i fix this?\\n #lambda_output_history was never initialized\\n print 'logic: '+lambdaCalc_output\\n parse(lambdaCalc_output)\",\n \"def parse_block_math(self, m):\\n self.tokens.append({\\n 'type': 'block_math',\\n 'text': m.group(1)\\n })\",\n \"def parse(self, message):\\n # The message does not contain the command name.\\n # self.args will become the parsed Namespace object.\\n\\n # For command aliases, add the prepend string\\n message = \\\"{} {}\\\".format(self.arguments_prepend, message)\\n\\n parser = self.get_parser()\\n\\n message = message.replace(\\\"'\\\", \\\"<<APOS>>\\\")\\n message = message.replace('\\\\\\\\\\\"', \\\"<<QUOT>>\\\") # explicit \\\\\\\"\\n try:\\n message = shlex.split(message, posix=False)\\n # posix=False does not remove quotes\\n message = [m.strip('\\\"') for m in message]\\n except ValueError as e:\\n # raised if shlex detects fucked up quotemarks\\n # message = message.split()\\n raise CommandParsingError(\\n \\\"Unmatched quotemark. Use \\\\\\\\\\\\\\\" to escape a literal quotemark\\\"\\n ) from e\\n message = [w.replace(\\\"<<APOS>>\\\", \\\"'\\\") for w in message]\\n message = [w.replace(\\\"<<QUOT>>\\\", '\\\"') for w in message]\\n try:\\n # Can throw ArgumentError\\n self.args = parser.parse_args(message)\\n except CommandParsingHelp as error:\\n # The error contains the get_usage string but I'm going to just\\n # ignore that\\n raise (\\n MyFaultError if self.__doc__ is None else CommandUsageMessage\\n )(self.make_command_help_string()) from error\",\n \"def lammps(step, atomnum, boxbounds, addson = ''):\\r\\n\\r\\n line = 'ITEM: TIMESTEP\\\\n'\\r\\n line += str(step) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: NUMBER OF ATOMS\\\\n'\\r\\n line += str(atomnum) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: BOX BOUNDS pp pp pp\\\\n'\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[0, 0], boxbounds[0, 1])\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[1, 0], boxbounds[1, 1])\\r\\n if boxbounds.shape[0] == 3:\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[2, 0], boxbounds[2, 1])\\r\\n else:\\r\\n line += '%.6f %.6f\\\\n' %(-0.5, 0.5)\\r\\n\\r\\n line += 'ITEM: ATOMS id type x y z %s\\\\n' %addson\\r\\n\\r\\n return line\",\n \"def readCommand( argv ): ## argv belongs to the 'sys'-library and can be called through sys.argv. The function reads the console's comand line argument and passes it to a variable like so: args = sys.argv[1:]\\n from optparse import OptionParser ## Option Parser is a powerful library for passing command line options (an advanced args) if you like. It allows you to add options by defining attributes. \\n usageStr = \\\"\\\"\\\" \\n USAGE: python pacman.py <options> \\n EXAMPLES: (1) python pacman.py\\n - starts an interactive game\\n (2) python pacman.py --layout smallClassic --zoom 2\\n OR python pacman.py -l smallClassic -z 2\\n - starts an interactive game on a smaller board, zoomed in\\n \\\"\\\"\\\" \\n parser = OptionParser(usageStr) ## This creates the Option Parser instance. It also passes the usageStr which functions as a little help-text for the user.\\n\\n ### In this section all the option strings are defined. Typically each option has one short option string and one long option string. For example the parser.add_option('-n'... has '-n' as short and '--numGames' as the long option string. Both have the same effect. The option argument will be the same and be saved as the variabme 'numGames'. \\n parser.add_option('-n', '--numGames', dest='numGames', type='int', \\n help=default('the number of GAMES to play'), metavar='GAMES', default=1) ## the syntax for the options is (based on the example in this line) --n 3. This means that the value '3' would be assigned to the variable numGames.\\n parser.add_option('-l', '--layout', dest='layout',\\n help=default('the LAYOUT_FILE from which to load the map layout'), #The instance -> 'options.layout' defines the layout_file from which to load the map layout; DEFAULT = medium_classic\\n metavar='LAYOUT_FILE', default='mediumClassic')\\n parser.add_option('-p', '--pacman', dest='pacman',\\n help=default('the agent TYPE in the pacmanAgents module to use'), #The instance -> 'options.pacman' defines which of the agent TYPE in the pacmanAgents moduleto use.\\n metavar='TYPE', default='KeyboardAgent')\\n parser.add_option('-t', '--textGraphics', action='store_true', dest='textGraphics',\\n help='Display output as text only', default=False)\\n parser.add_option('-q', '--quietTextGraphics', action='store_true', dest='quietGraphics',\\n help='Generate minimal output and no graphics', default=False)\\n parser.add_option('-g', '--ghosts', dest='ghost',\\n help=default('the ghost agent TYPE in the ghostAgents module to use'),\\n metavar = 'TYPE', default='RandomGhost')\\n parser.add_option('-k', '--numghosts', type='int', dest='numGhosts',\\n help=default('The maximum number of ghosts to use'), default=4)\\n parser.add_option('-z', '--zoom', type='float', dest='zoom',\\n help=default('Zoom the size of the graphics window'), default=1.0)\\n parser.add_option('-f', '--fixRandomSeed', action='store_true', dest='fixRandomSeed',\\n help='Fixes the random seed to always play the same game', default=False)\\n parser.add_option('-r', '--recordActions', action='store_true', dest='record',\\n help='Writes game histories to a file (named by the time they were played)', default=False)\\n parser.add_option('--replay', dest='gameToReplay',\\n help='A recorded game file (pickle) to replay', default=None)\\n parser.add_option('-a','--agentArgs',dest='agentArgs',\\n help='Comma separated values sent to agent. e.g. \\\"opt1=val1,opt2,opt3=val3\\\"')\\n parser.add_option('-x', '--numTraining', dest='numTraining', type='int',\\n help=default('How many episodes are training (suppresses output)'), default=0)\\n parser.add_option('--frameTime', dest='frameTime', type='float',\\n help=default('Time to delay between frames; <0 means keyboard'), default=0.1)\\n parser.add_option('-c', '--catchExceptions', action='store_true', dest='catchExceptions',\\n help='Turns on exception handling and timeouts during games', default=False)\\n parser.add_option('--timeout', dest='timeout', type='int',\\n help=default('Maximum length of time an agent can spend computing in a single game'), default=30)\\n\\n #ONCE ALL THE OPTIONS HAVE BEEN DEFINED, optparse is instructed to parse the programm's command line.\\n ##> The parser.parse_args() returns two values:\\n ### (A) OPTIONS: An object containing values for all of your options e.g.:e.g. if --file takes a single string argument, then options.file will be the filename supplied by the user, or None if the user did not supply that option\\n ### (B) ARGS: The list of positional arguments leftover after parsing options (we call this here otherjunk)\\n options, otherjunk = parser.parse_args(argv) ## if the user happens to accidentally enter a command other than the specified arguments specified by parser.add_option it is passed to otherjunk\\n if len(otherjunk) != 0: ## if there actually ends up to be a value in the otherjunk the program raises an Exception.\\n raise Exception('Command line input not understood: ' + str(otherjunk))\\n args = dict() # ARGS IS THE VARIABLE THAT IS BEING RETURNED BY THE readCommand function.\\n\\n # Fix the random seed\\n if options.fixRandomSeed: random.seed('cs188') # 'random.seed' is part of the random class. The random.seed([x]) command initialises a standard random number. Optional argument x can be any hashable object. \\n\\n # Choose a layout\\n args['layout'] = layout.getLayout( options.layout ) # REF_LAYOUT111: layout.py --> This function returns the layout object that was created by the layout class via the getlayout function. This contains the height, width, walls, food, captules and agent positions etc.\\n if args['layout'] == None: raise Exception(\\\"The layout \\\" + options.layout + \\\" cannot be found\\\")\\n\\n # Choose a Pacman agent\\n noKeyboard = options.gameToReplay == None and (options.textGraphics or options.quietGraphics) ## noKeyboard is set to TRUE if the user chooses the --replay and text- or silent graphics option.\\n ##print noKeyboard\\n pacmanType = loadAgent(options.pacman, noKeyboard) ## [see REFERENCE_001]: the loadAgent function takes the pacman argument the user passed into the command line as the option--pacman option identifies the appropriate agent (which may be the programmed agent or whost agent). \\n agentOpts = parseAgentArgs(options.agentArgs) ##Passes the option.agentArgs which was captured by the user's console input into the agentOps variable. agentArgs is: \\\"Comma separated values sent to agent. e.g. \\\"opt1=val1,opt2,opt3=val3. The ParseAgentArgs function converts the option - value pairings into a dictionary formatted opts[opt1] = val1. \\n if options.numTraining > 0: ##numTraining was captured by the user's console input and designates how many games are training games which means that the output remains surpressed.\\n args['numTraining'] = options.numTraining ## This takes the user's input as the -x or --numTraining and passes it to the args dictionary with the numTraining key as the args['numTraining'] variable.\\n if 'numTraining' not in agentOpts: agentOpts['numTraining'] = options.numTraining ## This integrates the variable entered into as training rounds in the agentOpts variable.\\n pacman = pacmanType(**agentOpts) ## REFERENCE002 ##Instantiate Pacman with agentOpts. ## The variable pacmanType contains a reference to agent module loaded by the load Agent function. This function does not cause the module to be instanciated. This happens when here ## See[REFERENCE_001]: ## The * and ** will 'soak up' any remaining values not otherwise accounted for. In this case these options are basically the agent options the user can input.\\n ## agentOpts contains the opts dictionary = {opt1:val1, opt2:val2, opt3:val3}; it also contains the numTraining variable as the ['numTraining'] key. As such it has the following structure. {opt1:val1,opt2:val2,opt3:val3, numTraining:int}.\\n args['pacman'] = pacman ## This passes the instanciated object to the agent dictionary containing the pacman key.\\n\\n # Don't display training games\\n if 'numTrain' in agentOpts: ## Checks whether the user has determined a certain number of training games. If they did, the number is passed on as an int to the options.numQuiet and option.numIgnore variables.\\n options.numQuiet = int(agentOpts['numTrain']) \\n options.numIgnore = int(agentOpts['numTrain'])\\n\\n # Choose a ghost agent\\n ghostType = loadAgent(options.ghost, noKeyboard) ## The options.ghost variable contains the user's ghost type preference as specified in the console.The user can choose between -g RandomGhost which is A ghost that chooses a legal action uniformly at random OR DirectionalGhost, a ghost that prefers to rush Pacman, or flee when scared.\\n args['ghosts'] = [ghostType( i+1 ) for i in range( options.numGhosts )] #instanciates as many ghost agents as the player requested by entering the desired number as -k', '--numghosts'in the console.\\n\\n # Choose a display format ##contains whether the game output is displayed as minimal output and no graphics (-q) text only (-t) or via graphicsDiplay (standard)\\n if options.quietGraphics: \\n import textDisplay\\n args['display'] = textDisplay.NullGraphics()\\n elif options.textGraphics:\\n import textDisplay\\n textDisplay.SLEEP_TIME = options.frameTime\\n args['display'] = textDisplay.PacmanGraphics()\\n else:\\n import graphicsDisplay ## This refers to the module that is responsible for the graphical representation of the game.\\n args['display'] = graphicsDisplay.PacmanGraphics(options.zoom, frameTime = options.frameTime) ## This line instanciates the PacmanGraphics class from the graphicsDisplay module and passes the reference to the args['display'] dictionary.\\n args['numGames'] = options.numGames \\n args['record'] = options.record\\n args['catchExceptions'] = options.catchExceptions\\n args['timeout'] = options.timeout\\n\\n # Special case: recorded games don't use the runGames method or args structure\\n if options.gameToReplay != None:\\n print 'Replaying recorded game %s.' % options.gameToReplay \\n import cPickle\\n f = open(options.gameToReplay)\\n try: recorded = cPickle.load(f)\\n finally: f.close()\\n recorded['display'] = args['display']\\n replayGame(**recorded)\\n sys.exit(0)\\n\\n return args #returns the args-dictionary which contains:\\n ##args['pacman'] which contains a dictionary of dictionaries of the agent that was loaded into args['numtraining'] = {agentOpts[opt1]: val1 ; agentOpts[opt2]:val2; agentOpts[opt3]:val3}\\n ##args['layout'] - this function returns the layout object that was created by the layout class via the getlayout function.\\n ##args['numTraining'] which contains which designates how many games are training games which means that the output remains surpressed\\n ##args['ghosts'] - contains the instanciated ghost agents in line with the number the user specified\\n ##args['display'] - contains whether the game output is displayed as minimal output and no graphics (-q) text only (-t) or via graphicsDiplay (standard)\\n ##args['numGames'] - the number of GAMES to play\\n ##args['record'] - Writes game histories to a file (named by the time they were played)\\n ##args['catchExceptions'] = options.catchExceptions - Turns on exception handling and timeouts during games\\n ##args['timeout'] = options.timeout -Maximum length of time an agent can spend computing in a single game\",\n \"def _parse_markdown(self):\\n renderer = MyRenderer()\\n md = mistune.Markdown(renderer=renderer)\\n md.render(self._markdown_text)\\n self._bash_commands = renderer._bash_commands\",\n \"async def getHelp(ctx, cmd):\\n wikiMods = discord.utils.get(ctx.message.author.guild.roles, name=\\\"Wiki Moderator\\\")\\n cmdInfo = next((c for c in COMMAND_INFO if c[\\\"name\\\"] == cmd or cmd in c[\\\"aliases\\\"]), None)\\n if cmdInfo == None:\\n return assembleEmbed(\\n title=f\\\"`{cmd}`\\\",\\n desc=\\\"Cannot find command with this name. Try again buddy.\\\",\\n webcolor=\\\"red\\\"\\n )\\n else:\\n roles = [(discord.utils.get(ctx.message.author.guild.roles, name=r)) for r in cmdInfo['access']]\\n commandFields = [\\n {\\n \\\"name\\\": \\\"Parameters\\\",\\n \\\"value\\\": \\\"\\\\n\\\".join([f\\\"`{p['name']}` - {p['description']}\\\" for p in cmdInfo['parameters']]) if len(cmdInfo['parameters']) > 0 else \\\"`none`\\\",\\n \\\"inline\\\": False\\n }\\n ]\\n # If command has flags show those, if not do nothing\\n if 'flags' in cmdInfo:\\n commandFields.append({\\n \\\"name\\\": \\\"Flags\\\",\\n \\\"value\\\": \\\"\\\\n\\\".join([f\\\"`-{u['name']}` - {u['description']}\\\" for u in cmdInfo['flags']]),\\n \\\"inline\\\": False\\n })\\n # Add available roles\\n commandFields.extend([\\n {\\n \\\"name\\\": \\\"Usage\\\",\\n \\\"value\\\": \\\"\\\\n\\\".join([f\\\"`{u['cmd']}` - {u['result']}\\\" for u in cmdInfo['usage']]),\\n \\\"inline\\\": False\\n },\\n {\\n \\\"name\\\": \\\"Available To\\\",\\n \\\"value\\\": \\\"\\\\n\\\".join([f\\\"{r.mention}\\\" for r in roles]),\\n \\\"inline\\\": False\\n }\\n ]\\n )\\n return assembleEmbed(\\n title=f\\\"`!{cmdInfo['name']}`\\\",\\n desc=f\\\"{cmdInfo['description']}\\\",\\n fields=commandFields,\\n webcolor=\\\"gold\\\"\\n )\",\n \"def parse():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dataset', default='ml-1m', help='which dataset to use')\\n args = parser.parse_args()\\n main(args)\",\n \"def _parse_word(self, token, ctxinfo) :\\n ignore = False\\n if token.startswith(\\\"|\\\") and token.endswith(\\\"|\\\") : # regular token\\n token = token[1:-1]\\n token_parts = token.rsplit( \\\"_\\\", 1 )\\n if len(token_parts) == 2 :\\n lemma_and_index, pos = token_parts\\n lemma_parts = lemma_and_index.rsplit( \\\":\\\", 1 )\\n if len(lemma_parts) == 2 : \\n lemma, index = lemma_parts\\n if lemma.endswith(\\\"\\\\\\\\\\\") :\\n lemma = lemma[:-1] # separator was \\\\: \\n else :\\n ignore = True\\n else :\\n ignore = True\\n if ignore :\\n ctxinfo.warn(\\\"Ignoring bad token `{token}`\\\", token=token)\\n return None\\n else : \\n return (lemma, index, pos)\",\n \"def __init__(\\n self,\\n terminators: Optional[Iterable[str]] = None,\\n multiline_commands: Optional[Iterable[str]] = None,\\n aliases: Optional[Dict[str, str]] = None,\\n shortcuts: Optional[Dict[str, str]] = None,\\n ) -> None:\\n self.terminators: Tuple[str, ...]\\n if terminators is None:\\n self.terminators = (constants.MULTILINE_TERMINATOR,)\\n else:\\n self.terminators = tuple(terminators)\\n self.multiline_commands: Tuple[str, ...] = tuple(multiline_commands) if multiline_commands is not None else ()\\n self.aliases: Dict[str, str] = aliases if aliases is not None else {}\\n\\n if shortcuts is None:\\n shortcuts = constants.DEFAULT_SHORTCUTS\\n\\n # Sort the shortcuts in descending order by name length because the longest match\\n # should take precedence. (e.g., @@file should match '@@' and not '@'.\\n self.shortcuts = tuple(sorted(shortcuts.items(), key=lambda x: len(x[0]), reverse=True))\\n\\n # commands have to be a word, so make a regular expression\\n # that matches the first word in the line. This regex has three\\n # parts:\\n # - the '\\\\A\\\\s*' matches the beginning of the string (even\\n # if contains multiple lines) and gobbles up any leading\\n # whitespace\\n # - the first parenthesis enclosed group matches one\\n # or more non-whitespace characters with a non-greedy match\\n # (that's what the '+?' part does). The non-greedy match\\n # ensures that this first group doesn't include anything\\n # matched by the second group\\n # - the second parenthesis group must be dynamically created\\n # because it needs to match either whitespace, something in\\n # REDIRECTION_CHARS, one of the terminators, or the end of\\n # the string (\\\\Z matches the end of the string even if it\\n # contains multiple lines)\\n #\\n invalid_command_chars = []\\n invalid_command_chars.extend(constants.QUOTES)\\n invalid_command_chars.extend(constants.REDIRECTION_CHARS)\\n invalid_command_chars.extend(self.terminators)\\n # escape each item so it will for sure get treated as a literal\\n second_group_items = [re.escape(x) for x in invalid_command_chars]\\n # add the whitespace and end of string, not escaped because they\\n # are not literals\\n second_group_items.extend([r'\\\\s', r'\\\\Z'])\\n # join them up with a pipe\\n second_group = '|'.join(second_group_items)\\n # build the regular expression\\n expr = rf'\\\\A\\\\s*(\\\\S*?)({second_group})'\\n self._command_pattern = re.compile(expr)\",\n \"def parse(self, filehandle):\\n l = filehandle.readline()\\n if l.split()[0] != '##maf':\\n return\\n else:\\n self.setpar(l.split()[1:])\\n\\n l=filehandle.readline()\\n while l:\\n la = l.split()\\n## print la\\n if(len(la)==0 or la[0]=='#'):\\n## print \\\"skipping\\\"\\n 1\\n elif(la[0]=='a'):\\n## print \\\"reading alignment\\\"\\n self.readalign(la[1:], filehandle)\\n else:\\n## print \\\"end of records\\\"\\n return\\n\\n l=filehandle.readline()\",\n \"def law(self, line):\\n line = line.strip()\\n if not line:\\n logger.error(r\\\"the command passed to %law must not be empty\\\")\\n return\\n\\n # build the full command\\n cmd = \\\"law \\\" + line\\n if line_cmd:\\n cmd = \\\"{} && {}\\\".format(line_cmd, cmd)\\n logger.debug(\\\"running law command '{}'\\\".format(cmd))\\n\\n # run it\\n return self._run_bash(cmd)\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description=__doc__)\\n parser.add_argument('--version', action='version',\\n version=\\\"iswitch version \\\" + get_version())\\n\\n # Can't require a subparser because of need to maintain\\n # backwards compatibility with Python 3.6\\n subparsers = parser.add_subparsers(\\n dest='command', help='command')\\n\\n pwd_parser = subparsers.add_parser(\\\"pwd\\\",\\n help='Print working directory/collection')\\n pwd_parser.add_argument('--verbose', '-v', action='store_true', default=False,\\n help='Print verbose information for troubleshooting')\\n\\n cd_parser = subparsers.add_parser(\\\"cd\\\",\\n help='Change working directory/collection')\\n cd_parser.add_argument('--verbose', '-v', action='store_true', default=False,\\n help='Print verbose information for troubleshooting')\\n cd_parser.add_argument('directory', default=None, nargs='?',\\n help='Directory to change to')\\n\\n ls_parser = subparsers.add_parser(\\\"ls\\\",\\n help='List collections or data objects')\\n ls_parser.add_argument('--verbose', '-v', action='store_true', default=False,\\n help='Print verbose information for troubleshooting')\\n ls_parser.add_argument('queries', default=None, nargs='*',\\n help='Collection, data object or data object wildcard')\\n ls_parser.add_argument(\\\"-m\\\", \\\"--format\\\", dest='format', default='plain',\\n help=\\\"Output format\\\", choices=['plain', 'json', 'csv', \\\"yaml\\\"])\\n ls_parser.add_argument(\\\"-s\\\", \\\"--sort\\\", dest=\\\"sort\\\", default='name',\\n help=\\\"Propery to use for sorting\\\", choices=['name', 'ext', 'size', 'date', \\\"unsorted\\\"])\\n ls_parser.add_argument(\\\"-H\\\", \\\"--hr-size\\\", default='default', dest=\\\"hrsize\\\",\\n help=\\\"Whether to print human-readable sizes [yes,no,default].\\\" +\\n \\\"By default, enable human-readable for text output, disable for other formats.\\\",\\n choices=['default', 'yes', 'no'])\\n ls_parser.add_argument('--recursive', '-r', action='store_true', default=False,\\n help='Include contents of subcollections')\\n ls_parser.add_argument('-l', action='store_true', default=False,\\n help='Display replicas with size, resource, owner, date')\\n ls_parser.add_argument('-L', action='store_true', default=False,\\n help='like -l, but also display checksum and physical path')\\n\\n help_hrs = \\\" (you can optionally use human-readable sizes, like \\\\\\\"2g\\\\\\\" for 2 gigabytes)\\\"\\n find_parser = subparsers.add_parser(\\\"find\\\",\\n help='Find data objects by property')\\n find_parser.add_argument('--verbose', '-v', action='store_true', default=False,\\n help='Print verbose information for troubleshooting')\\n find_parser.add_argument('queries', default=None, nargs='*',\\n help='Collection, data object or data object wildcard')\\n find_parser.add_argument('--print0', '-0', action='store_true', default=False,\\n help='Use 0 byte delimiters between results')\\n find_parser.add_argument(\\n \\\"--dname\\\",\\n help=\\\"Wildcard filter for data object name\\\")\\n find_parser.add_argument(\\n \\\"--owner-name\\\",\\n help=\\\"Filter for data object owner name (excluding zone)\\\")\\n find_parser.add_argument(\\\"--owner-zone\\\",\\n help=\\\"Filter for data object owner zone\\\")\\n find_parser.add_argument(\\\"--resc-name\\\",\\n help=\\\"Filter for data object resource\\\")\\n find_parser.add_argument(\\n \\\"--minsize\\\",\\n help=\\\"Filter for minimum data object size\\\" +\\n help_hrs)\\n find_parser.add_argument(\\n \\\"--maxsize\\\",\\n help=\\\"Filter for maximum data object size\\\" +\\n help_hrs)\\n find_parser.add_argument(\\n \\\"--size\\\",\\n help=\\\"Filter for (exact) data object size\\\" +\\n help_hrs)\\n\\n if len(sys.argv) == 1:\\n parser.print_help()\\n parser.exit()\\n\\n return vars(parser.parse_args())\",\n \"def default(self, line):\\n lexer = shlex.shlex(line)\\n lexer.wordchars += \\\"-\\\"\\n lexer = list(lexer)\\n arg = []\\n func_name = \\\"\\\"\\n idx = 0\\n in_paren = False\\n\\n while idx < len(lexer):\\n if lexer[idx][0].islower() is True and func_name == \\\"\\\":\\n func_name = lexer[idx]\\n elif in_paren is True:\\n if lexer[idx] == \\\"[\\\":\\n idx_start = lexer.index(\\\"[\\\")\\n idx_end = lexer.index(\\\"]\\\")\\n list_str = \\\"\\\".join(lexer[idx_start:idx_end + 1])\\n arg.append(eval(list_str))\\n idx = idx_end\\n if lexer[idx] == \\\"{\\\":\\n dict_str = \\\"\\\".join(lexer[idx:-1])\\n dict_str = dict_str.replace(\\\"'\\\", '\\\"')\\n arg.append(json.loads(dict_str))\\n idx = len(lexer) - 1\\n if lexer[idx] not in \\\",)\\\":\\n arg.append(lexer[idx].replace('\\\"', \\\"\\\").replace(\\\"'\\\", \\\"\\\"))\\n elif lexer[idx] == \\\"(\\\":\\n in_paren = True\\n elif lexer[idx] != \\\".\\\":\\n arg.append(lexer[idx].replace('\\\"', \\\"\\\").replace(\\\"'\\\", \\\"\\\"))\\n idx += 1\\n\\n cmd_list = (\\\"all\\\", \\\"count\\\", \\\"show\\\", \\\"destroy\\\", \\\"update\\\")\\n if func_name in cmd_list:\\n eval(\\\"self.do_\\\" + func_name + \\\"(arg)\\\")\",\n \"def cmdline_parser():\\n parser = argparse.ArgumentParser(description=\\\"\\\"\\\" \\\"\\\"\\\")\\n parser.add_argument(\\\"-g\\\", \\\"--gta\\\",\\n help=\\\"\\\"\\\"gta sequences\\\"\\\"\\\",\\n dest=\\\"gta\\\",\\n required=True)\\n return parser\",\n \"def OnModCommand(self, message):\\n\\n argument = QuotedString(quoteChar='(', endQuoteChar=')', escChar='\\\\\\\\') | Regex(r'(?!--)[^\\\\s]+')\\n arguments = ZeroOrMore(argument)\\n command = Word(alphas)\\n kwarg = command+Suppress(Optional(Literal('=')))+argument\\n kwargs = Suppress(Literal('--')) + ZeroOrMore(kwarg.setParseAction(tuple))\\n commandWithArgs = StringStart() + command + Group(arguments) + Group(Optional(kwargs)) + StringEnd()\\n\\n try:\\n pCommand, args, kw = commandWithArgs.parseString(message)\\n except ParseException as e:\\n self.PutModule('Invalid command {}'.format(e))\\n return znc.CONTINUE\\n\\n\\n if not pCommand:\\n self.PutModule('No command')\\n return znc.CONTINUE\\n\\n method = getattr(self, 'cmd_' + pCommand.lower(), None)\\n\\n if method is None:\\n self.PutModule('Invalid command {}'.format(pCommand))\\n return znc.CONTINUE\\n\\n try:\\n method(*args, **dict(list(kw)))\\n except TypeError as e:\\n self.PutModule('Usage: {}{}\\\\n{}'.format(pCommand, signature(method), e))\\n return znc.CONTINUE\\n\\n return znc.CONTINUE\",\n \"def magic(self, alias):\\n if alias in self.aliases:\\n return self.aliases[alias]\\n else:\\n return \\\"%%{}\\\\n\\\".format(alias)\",\n \"def parseCmdLine(cmdLine):\\n files=[]\\n modifiers=[]\\n for i in range(len(cmdLine)):\\n arg = cmdLine[i]\\n if arg[:2] != '--':\\n files = cmdLine[i:]\\n return (modifiers, files)\\n \\n arg = arg[2:]\\n parts = arg.split('=',1)\\n modifiers.append((parts[0], parts[1]))\\n return (modifiers, files)\",\n \"def help_util():\\r\\n for cmd, f in COMMANDS.items():\\r\\n print(\\\"POM \\\" + cmd + \\\":\\\")\\r\\n print(f.__doc__.lstrip(\\\"\\\\n\\\"))\",\n \"def autosuggest_ml(self, suggest, focus=None, clip=None, display='full',\\n format='json', lang=None):\\n\\n params = {\\n 'addr': suggest,\\n 'display': display,\\n 'format': format,\\n 'lang': lang or self.lang,\\n }\\n if focus:\\n params.update({\\n 'focus': focus\\n })\\n if clip:\\n params.update({\\n 'clip': clip\\n })\\n\\n return self._request('/autosuggest-ml', params)\",\n \"def parse(self, command_line=sys.argv[1:]):\\n return self._parser.parse_args(command_line)\",\n \"def pymssql_mixin_parser_kwargs():\\n config_path = \\\"./config.json\\\"\\n config: Dict[str, Any] = {}\\n dump_json_file(config, config_path)\\n\\n model = Model(name=\\\"test\\\", version=\\\"0.0.1\\\")\\n model_path = \\\"./model.pkl\\\"\\n dump_pickle_file(model, model_path)\\n\\n mssql_uri = \\\"mssql+pymssql://mssql?test\\\"\\n\\n argv = [\\n \\\"--config\\\",\\n config_path,\\n \\\"--model\\\",\\n model_path,\\n \\\"--mssql-uri\\\",\\n mssql_uri,\\n ]\\n parser = ArgumentParser()\\n return {\\\"argv\\\": argv, \\\"parser\\\": parser}\",\n \"def _parse_args():\\n parser = argparse.ArgumentParser(description='Pure-python command-line calculator.')\\n\\n parser.add_argument('EXPRESSION', action=\\\"store\\\", type=str, help=\\\"expression string to evaluate\\\")\\n parser.add_argument('-m', '--use-modules', nargs='+', action=\\\"store\\\", dest=\\\"MODULE\\\", type=str,\\n help=\\\"additional modules to use\\\")\\n\\n return parser.parse_args()\",\n \"def podman(self, command: Command, **kwargs: Any) -> tmt.utils.CommandOutput:\\n return self.run(Command('podman') + command, **kwargs)\",\n \"def test_markdown(self):\\n with sphinx_build('pyexample'):\\n with open('_build/text/docfx_yaml/example.example.Foo.yml') as yml_file:\\n data = yaml.safe_load(yml_file)\\n for item in data['items']:\\n if item['uid'] == 'example.example.Foo.method_markdown':\\n self.assertEqual(\\n item['summary'],\\n 'Check out our '\\n '[site](http://sphinx-docfx-yaml.readthedocs.io/en/latest/)'\\n ' for more info.',\\n )\",\n \"def db_yamls(db):\\n return utils.db.db_yamls(db)\",\n \"def parse_misc(self,ins):\\n if ins.instr == 'nop':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'syscall':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'break':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'mflo': \\n if len(ins.args) == 1:\\n self.gen = [ins.args[0]]\\n self.need = [Register(\\\"$lo\\\")]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mtlo': \\n if len(ins.args) == 1:\\n self.gen = [Register(\\\"$lo\\\")]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mfhi': \\n if len(ins.args) == 1:\\n self.gen = [ins.args[0]]\\n self.need = [Register(\\\"$hi\\\")]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mthi': \\n if len(ins.args) == 1:\\n self.gen = [Register(\\\"$hi\\\")]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mtc1': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[1]]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mfc1': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.need = [ins.args[1]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'la': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.ival = ins.args[1]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'lui': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.ival = ins.args[1]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\",\n \"def test_yaml(maptype, get_obs, parse_obs):\\n eq = lambda a, b: a == b\\n seteq = lambda a, b: len(a) == len(b) and set(a) == set(b)\\n checks = {OrdAttMap: eq, PathExAttMap: eq, AttMapEcho: eq, AttMap: seteq}\\n m = make_data(ENTRIES, maptype)\\n check_lines(m, EXPLINES, get_obs, parse_obs, check=checks[maptype])\",\n \"def test_features(self):\\n assert list(parser.generate_commands(yaml.load(\\n '- my_command: {name: my_name}'))) == [('my_command', {'name': 'my_name'})]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.670974","0.5512939","0.51862484","0.5175543","0.50888264","0.49876153","0.49551958","0.49524027","0.49337393","0.4880694","0.48664626","0.48470613","0.4794826","0.47836807","0.4777479","0.47459564","0.47455326","0.4718852","0.46997732","0.46576157","0.46563837","0.46510884","0.4574563","0.45364666","0.45285183","0.4514571","0.4444257","0.44426432","0.4435859","0.44356012","0.4428431","0.44277403","0.44191888","0.44146577","0.44073182","0.44036728","0.44036192","0.43960384","0.43958795","0.43894103","0.43699476","0.4343583","0.4340203","0.43344373","0.4333222","0.43187496","0.4317169","0.431637","0.43073606","0.43006074","0.4295104","0.42928258","0.42829397","0.4276043","0.42606187","0.42572567","0.42458302","0.42443058","0.42400548","0.42388263","0.42358917","0.423511","0.42327237","0.4226131","0.4225625","0.42248273","0.42238352","0.4223506","0.42160273","0.42090952","0.4208817","0.42046773","0.4202693","0.4186221","0.41821095","0.41812873","0.41788033","0.41777825","0.41733867","0.41724405","0.41673094","0.4160906","0.41531083","0.41472325","0.4146783","0.41459632","0.4144613","0.41437173","0.41420498","0.41312304","0.41308796","0.41293156","0.41261446","0.412464","0.41112083","0.4108616","0.41081402","0.4104226","0.41012308","0.40934646"],"string":"[\n \"0.670974\",\n \"0.5512939\",\n \"0.51862484\",\n \"0.5175543\",\n \"0.50888264\",\n \"0.49876153\",\n \"0.49551958\",\n \"0.49524027\",\n \"0.49337393\",\n \"0.4880694\",\n \"0.48664626\",\n \"0.48470613\",\n \"0.4794826\",\n \"0.47836807\",\n \"0.4777479\",\n \"0.47459564\",\n \"0.47455326\",\n \"0.4718852\",\n \"0.46997732\",\n \"0.46576157\",\n \"0.46563837\",\n \"0.46510884\",\n \"0.4574563\",\n \"0.45364666\",\n \"0.45285183\",\n \"0.4514571\",\n \"0.4444257\",\n \"0.44426432\",\n \"0.4435859\",\n \"0.44356012\",\n \"0.4428431\",\n \"0.44277403\",\n \"0.44191888\",\n \"0.44146577\",\n \"0.44073182\",\n \"0.44036728\",\n \"0.44036192\",\n \"0.43960384\",\n \"0.43958795\",\n \"0.43894103\",\n \"0.43699476\",\n \"0.4343583\",\n \"0.4340203\",\n \"0.43344373\",\n \"0.4333222\",\n \"0.43187496\",\n \"0.4317169\",\n \"0.431637\",\n \"0.43073606\",\n \"0.43006074\",\n \"0.4295104\",\n \"0.42928258\",\n \"0.42829397\",\n \"0.4276043\",\n \"0.42606187\",\n \"0.42572567\",\n \"0.42458302\",\n \"0.42443058\",\n \"0.42400548\",\n \"0.42388263\",\n \"0.42358917\",\n \"0.423511\",\n \"0.42327237\",\n \"0.4226131\",\n \"0.4225625\",\n \"0.42248273\",\n \"0.42238352\",\n \"0.4223506\",\n \"0.42160273\",\n \"0.42090952\",\n \"0.4208817\",\n \"0.42046773\",\n \"0.4202693\",\n \"0.4186221\",\n \"0.41821095\",\n \"0.41812873\",\n \"0.41788033\",\n \"0.41777825\",\n \"0.41733867\",\n \"0.41724405\",\n \"0.41673094\",\n \"0.4160906\",\n \"0.41531083\",\n \"0.41472325\",\n \"0.4146783\",\n \"0.41459632\",\n \"0.4144613\",\n \"0.41437173\",\n \"0.41420498\",\n \"0.41312304\",\n \"0.41308796\",\n \"0.41293156\",\n \"0.41261446\",\n \"0.412464\",\n \"0.41112083\",\n \"0.4108616\",\n \"0.41081402\",\n \"0.4104226\",\n \"0.41012308\",\n \"0.40934646\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.740539"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20184,"cells":{"query":{"kind":"string","value":"Defines magic command ``%%maml``."},"document":{"kind":"string","value":"def maml(self, line, cell):\n parser = self.get_parser(CsMLMagics.maml_parser, \"maml\")\n args = self.get_args(line, parser)\n\n if args is not None:\n quiet = args.quiet\n out, err = maml(cell, not quiet)\n if out:\n print(out)\n if err:\n print('-----')\n print(err)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def maml_parser():\n parser = MagicCommandParser(prog=\"maml\",\n description='Runs a maml script.')\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\n help='hide output')\n return parser","def command(self,cmd):\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))","def command(self, cmd):\n self.lmp.command(cmd)","def magic_lsmagic(self, parameter_s = ''):\n print 'Available magic functions:\\n@'+' @'.join(self.lsmagic())\n print '\\n' + Magic.auto_status[self.rc.automagic]\n return None","def magic_magic(self, parameter_s = ''):\n\n mode = ''\n try:\n if parameter_s.split()[0] == '-latex':\n mode = 'latex'\n except:\n pass\n\n magic_docs = []\n for fname in self.lsmagic():\n mname = 'magic_' + fname\n for space in (Magic,self,self.__class__):\n try:\n fn = space.__dict__[mname]\n except KeyError:\n pass\n else:\n break\n magic_docs.append('@%s:\\n\\t%s\\n' %(fname,fn.__doc__))\n magic_docs = ''.join(magic_docs)\n\n if mode == 'latex':\n print self.format_latex(magic_docs)\n return\n else:\n magic_docs = self.format_screen(magic_docs)\n \n outmsg = \"\"\"\nIPython's 'magic' functions\n===========================\n\nThe magic function system provides a series of functions which allow you to\ncontrol the behavior of IPython itself, plus a lot of system-type\nfeatures. All these functions are prefixed with a @ character, but parameters\nare given without parentheses or quotes.\n\nExample: typing '@cd mydir' (without the quotes) changes you working directory\nto 'mydir', if it exists.\n\nIf you have 'automagic' enabled (via the command line option or with the\n@automagic function), you don't need to type in the @ explicitly.\n\nYou can define your own magic functions to extend the system. See the supplied\nipythonrc and example-magic.py files for details (in your ipython\nconfiguration directory, typically $HOME/.ipython/).\n\nYou can also define your own aliased names for magic functions. In your\nipythonrc file, placing a line like:\n\n execute __IP.magic_cl = __IP.magic_clear\n\nwill define @cl as a new name for @clear.\n\nFor a list of the available magic functions, use @lsmagic. For a description\nof any of them, type @magic_name?.\n\nCurrently the magic system has the following functions:\\n\"\"\"\n\n outmsg = (\"%s\\n%s\\n\\nSummary of magic functions (from @lsmagic):\"\n \"\\n\\n@%s\\n\\n%s\" % (outmsg,\n magic_docs,\n ' @'.join(self.lsmagic()),\n Magic.auto_status[self.rc.automagic] ) )\n\n page(outmsg,screen_lines=self.rc.screen_length)","def handle_magic(self, line, continue_prompt=None,\n pre=None,iFun=None,theRest=None):\n\n cmd = '%sipmagic(\"%s\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\n self.log(cmd,continue_prompt)\n self.update_cache(line)\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\n return cmd","def man(command):\n\tspeech.speak(\"Executing 'man \" + command + \"' to show you documentation for this command.\")\n\tsubprocess.call([\"man\", command])","def maml(self, maml: List[PredictionsDatapoints]):\n\n self._maml = maml","def set_m(self, varname: str, varval: Optional[str]) -> None:\n if varname:\n self.pandoc.append('-M')\n self.pandoc.append(f'{varname}={varval}')","def magic2python(cmd):\n\n if cmd.startswith('#@') or cmd.startswith('@'):\n if cmd[0]=='#':\n cmd = cmd[1:]\n # we need to return the proper line end later\n if cmd[-1] == '\\n':\n endl = '\\n'\n else:\n endl = ''\n try:\n func,args = cmd[1:].split(' ',1)\n except:\n func,args = cmd[1:].rstrip(),''\n args = args.replace('\"','\\\\\"').replace(\"'\",\"\\\\'\").rstrip()\n return '__IP.magic_%s (\"%s\")%s' % (func,args,endl)\n else:\n return cmd","def niw_mmml_mp(args):\n return niw_mmml(*args)","def _make_matlab_command(self):\n \n raise NotImplementedError","def magic(self, parameter_s=''):\n\n mode = ''\n try:\n mode = parameter_s.split()[0][1:]\n except IndexError:\n pass\n\n brief = (mode == 'brief')\n rest = (mode == 'rest')\n magic_docs = self._magic_docs(brief, rest)\n\n if mode == 'latex':\n print(self.format_latex(magic_docs))\n return\n else:\n magic_docs = format_screen(magic_docs)\n\n out = [\"\"\"\nIPython's 'magic' functions\n===========================\n\nThe magic function system provides a series of functions which allow you to\ncontrol the behavior of IPython itself, plus a lot of system-type\nfeatures. There are two kinds of magics, line-oriented and cell-oriented.\n\nLine magics are prefixed with the % character and work much like OS\ncommand-line calls: they get as an argument the rest of the line, where\narguments are passed without parentheses or quotes. For example, this will\ntime the given statement::\n\n %timeit range(1000)\n\nCell magics are prefixed with a double %%, and they are functions that get as\nan argument not only the rest of the line, but also the lines below it in a\nseparate argument. These magics are called with two arguments: the rest of the\ncall line and the body of the cell, consisting of the lines below the first.\nFor example::\n\n %%timeit x = numpy.random.randn((100, 100))\n numpy.linalg.svd(x)\n\nwill time the execution of the numpy svd routine, running the assignment of x\nas part of the setup phase, which is not timed.\n\nIn a line-oriented client (the terminal or Qt console IPython), starting a new\ninput with %% will automatically enter cell mode, and IPython will continue\nreading input until a blank line is given. In the notebook, simply type the\nwhole cell as one entity, but keep in mind that the %% escape can only be at\nthe very start of the cell.\n\nNOTE: If you have 'automagic' enabled (via the command line option or with the\n%automagic function), you don't need to type in the % explicitly for line\nmagics; cell magics always require an explicit '%%' escape. By default,\nIPython ships with automagic on, so you should only rarely need the % escape.\n\nExample: typing '%cd mydir' (without the quotes) changes your working directory\nto 'mydir', if it exists.\n\nFor a list of the available magic functions, use %lsmagic. For a description\nof any of them, type %magic_name?, e.g. '%cd?'.\n\nCurrently the magic system has the following functions:\"\"\",\n magic_docs,\n \"Summary of magic functions (from %slsmagic):\" % magic_escapes['line'],\n str(self.lsmagic()),\n ]\n page.page('\\n'.join(out))","async def man(self, ctx: Context, *, command: str) -> None:\n base_query = f\"https://www.mankier.com/api/v2/mans/?q={command}\"\n query_url = urllib.parse.quote_plus(base_query, safe=\";/?:@&=$,><-[]\")\n\n async with ctx.typing():\n # Get API query responses\n async with self.session.get(query_url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n results = json.loads(await response.text())[\"results\"]\n\n # Use first result\n if len(results) > 0:\n result = results[0]\n else:\n await ctx.send(\"Invalid query, no such command\")\n return\n\n base_url = f\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\"\n url = urllib.parse.quote_plus(base_url, safe=\";/?:@&=$,><-[]\")\n\n # Load man page from first result\n async with self.session.get(url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n result = json.loads(await response.text())\n\n embed = Embed(\n title=f\"Man page of: **{result['name'].capitalize()}**\",\n url=result[\"url\"],\n description=f\"**{result['description']}** ({result['section']})\"\n )\n\n for anchor in result['anchors']:\n embed.add_field(\n name=f\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\",\n value=f\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\n[Link here]({anchor['url']})\",\n inline=False\n )\n # TODO: Solve this with pagination\n try:\n await ctx.send(embed=embed)\n except HTTPException as e:\n if e.code == 50035:\n await ctx.send(embed=Embed(\n description=\"Body is too long to show\",\n color=Color.red()\n ))\n else:\n raise e","def magic_ll(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^l')","def mlnet_parser():\n parser = MagicCommandParser(prog=\"mlnet\",\n description='Compiles and wrap a C# function into a Python function.\\n'\n 'Automatically adds ML.net dependencies.')\n parser.add_argument('name', type=str, help='function name')\n parser.add_argument('-i', '--idep', nargs='*', action='append',\n help='internal dependencies (like System, System.Linq)')\n parser.add_argument('-d', '--dep', nargs='*', action='append',\n help='dependencies (assembly name without extension)')\n parser.add_argument('-c', '--catch', action='store', default=False,\n help='catch exception')\n return parser","def _llm_type(self) -> str:\n return \"llama.cpp\"","def getArbitraryManInput(self):\n return \"\"\".TH MANHOLE \"1\" \"August 2001\" \"\" \"\"\n.SH NAME\nmanhole \\- Connect to a Twisted Manhole service\n.SH SYNOPSIS\n.B manhole\n.SH DESCRIPTION\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\ncode as if at an interactive Python console inside a running Twisted process\nwith this.\"\"\"","def yamlmain(argv=None):\n if argv is None:\n argv = sys.argv\n if len(argv) == 1:\n _fullusage()\n try:\n command = argv[1]\n if command in ['get', 'dump']:\n _rosparam_cmd_get_dump(command, argv)\n elif command in ['set', 'load']:\n _rosparam_cmd_set_load(command, argv)\n elif command in ['delete']:\n _rosparam_cmd_delete(argv)\n elif command == 'list':\n _rosparam_cmd_list(argv)\n else:\n _fullusage()\n except RosParamException as e:\n print(\"ERROR: \"+str(e), file=sys.stderr)\n sys.exit(1)","def add_command(self):\n self.write(\"@SP\\nAM=M-1\\nD=M\\nA=A-1\\nM=M+D\\n\")","def __getattr__(self, item):\n if item not in _CommandsMetaClass.commands_dict:\n raise MPDCommandNotExists(\"no such command: '{}'\".format(item))\n\n f = lambda *args: \"{} {}\\n\".format(item, ' '.join(_CommandsMetaClass._quote_arguments(args)))\n f.__doc__ = \"Command's Arguments: {}\".format(_CommandsMetaClass.commands_dict[item])\n f.__name__ = item\n return f","def magic_alias(self, parameter_s = ''):\n\n par = parameter_s.strip()\n if not par:\n if self.rc.automagic:\n prechar = ''\n else:\n prechar = '@'\n print 'Alias\\t\\tSystem Command\\n'+'-'*30\n aliases = self.alias_table.keys()\n aliases.sort()\n for alias in aliases:\n print prechar+alias+'\\t\\t'+self.alias_table[alias]\n return\n try:\n alias,cmd = par.split(' ',1)\n except:\n print inspect.getdoc(self.magic_alias)\n return\n nargs = cmd.count('%s')\n if nargs == 0: # simple aliases\n fndef = itpl(\n\"\"\"\ndef magic_${alias}(parameter_s = ''):\n '''Alias to the system command '$cmd' '''\n xsys('$cmd '+str(parameter_s))\n\nself.magic_$alias = magic_$alias\n\"\"\")\n else: # parametric aliases\n fndef = itpl(\n\"\"\"\ndef magic_${alias}(parameter_s = ''):\n '''Alias to the system command '$cmd' '''\n cmd = '$cmd'\n nargs = cmd.count('%s')\n args = str(parameter_s).split()\n\n if len(args) != nargs:\n print 'Incorrect number of arguments:',nargs,'expected.'\n print \"$alias is an alias to: '$cmd'\"\n return\n else:\n cmd_call = cmd % tuple(args)\n xsys(cmd_call)\n\nself.magic_$alias = magic_$alias\n\"\"\")\n try:\n exec fndef in globals(),locals()\n except:\n print self.magic_alias.__doc__\n self.alias_table.update({alias:cmd})","def cmd(name: str) -> Callable:\n return g.new_cmd_decorator(name, ['c', 'spellCommands',])","def yamllint(context):\n exec_cmd = \"yamllint .\"\n run_cmd(context, exec_cmd)","def magic_macro(self,parameter_s = ''):\n\n args = parameter_s.split()\n name,ranges = args[0], args[1:]\n #print 'rng',ranges # dbg\n cmds = self.extract_input_slices(ranges)\n macro = Macro(cmds)\n self.user_ns.update({name:macro})\n print 'Macro `%s` created. To execute, type its name (without quotes).' % name\n print 'Macro contents:'\n print str(macro).rstrip(),","def magic(self, alias):\n if alias in self.aliases:\n return self.aliases[alias]\n else:\n return \"%%{}\\n\".format(alias)","def doautocmd(self, *autocmds):\n self._vim.command('doautocmd ' + ','.join(autocmds))","def mfa_cli(ctx: click.Context) -> None:\n from montreal_forced_aligner.command_line.utils import check_server, start_server, stop_server\n\n config.load_configuration()\n auto_server = False\n run_check = True\n if ctx.invoked_subcommand == \"anchor\":\n config.CLEAN = False\n config.USE_POSTGRES = True\n config.CLEAN = False\n config.USE_POSTGRES = True\n if \"--help\" in sys.argv or ctx.invoked_subcommand in [\n \"configure\",\n \"version\",\n \"history\",\n \"server\",\n \"align_one\",\n ]:\n auto_server = False\n run_check = False\n elif ctx.invoked_subcommand in [\"model\", \"models\"]:\n if \"add_words\" in sys.argv or \"inspect\" in sys.argv:\n config.CLEAN = True\n config.USE_POSTGRES = False\n else:\n run_check = False\n elif ctx.invoked_subcommand == \"g2p\":\n if len(sys.argv) > 2 and sys.argv[2] == \"-\":\n run_check = False\n auto_server = False\n else:\n auto_server = config.AUTO_SERVER\n if \"--no_use_postgres\" in sys.argv or not config.USE_POSTGRES:\n run_check = False\n auto_server = False\n if auto_server:\n start_server()\n elif run_check:\n check_server()\n warnings.simplefilter(\"ignore\")\n check_third_party()\n if ctx.invoked_subcommand != \"anchor\":\n hooks = ExitHooks()\n hooks.hook()\n atexit.register(hooks.history_save_handler)\n if auto_server:\n atexit.register(stop_server)","def command(name):\n def _decoration(fcn):\n fcn.command = name\n return fcn\n return _decoration","def load_alias(name):\n mod = importlib.import_module(\"umdone.commands.\" + name)\n main = getattr(mod, \"main\")\n builtins.aliases[name] = main\n builtins.aliases[name.replace(\"_\", \"-\")] = main","def law(self, line):\n line = line.strip()\n if not line:\n logger.error(r\"the command passed to %law must not be empty\")\n return\n\n # build the full command\n cmd = \"law \" + line\n if line_cmd:\n cmd = \"{} && {}\".format(line_cmd, cmd)\n logger.debug(\"running law command '{}'\".format(cmd))\n\n # run it\n return self._run_bash(cmd)","def vim_normal_mode_exterm(cmd: str):\n v = VimMode()\n v.set_normal_mode_exterm()\n actions.insert(cmd)","def add_cmd(self, func, is_admin=False):\n method = {}\n vals = func.func_name.split('_')\n if vals[0] == 'void':\n method['template'] = void_template\n elif vals[0] == 'string':\n method['template'] = string_template\n elif vals[0] == 'begin':\n method['template'] = begin_template\n else:\n method['template'] = list_template\n method['cmd'] = vals[1].upper()\n if not vals[0] in self.templates:\n msg = \"The first part of the function name must be %s\" % str(self.templates)\n raise NamingError(msg)\n if is_admin:\n method['perm'] = 'M'\n else:\n method['perm'] = 'r'\n args = inspect.getargspec(func)[0]\n if 'args' in args:\n method['has_arg'] = True\n method['inst'] = \"Syntax %s <sp> args\" % method['cmd']\n else:\n method['has_arg'] = False\n method['inst'] = \"Syntax %s\" % method['cmd']\n made = self.arg_maker(args)\n method['need'] = made[0]\n method['arg'] = made[1]\n method['func'] = func.__name__\n method['mod'] = func.__module__\n self.methods += [method]","def lsmagic(self, parameter_s=''):\n return MagicsDisplay(self.shell.magics_manager, ignore=[])","def at_cmdset_creation(self):\n self.add(default_cmds.CmdLook())\n self.add(default_cmds.CmdSay())","def _from_command_line():\n # Manim can be called from the command line in three different\n # ways. The first two involve using the manim or manimcm commands\n prog = os.path.split(sys.argv[0])[-1]\n from_cli_command = prog in [\"manim\", \"manimcm\"]\n\n # The third way involves using `python -m manim ...`. In this\n # case, the CLI arguments passed to manim do not include 'manim',\n # 'manimcm', or even 'python'. However, the -m flag will always\n # be the first argument.\n from_python_m = sys.argv[0] == \"-m\"\n\n return from_cli_command or from_python_m","def test_macro(self):\n env = create_env()\n pkg = create_manifest(\"mock\")\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test)\n cmd2()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([], result)\n\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test)\n if()\n cmd()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([\"INDENTATION\"], result)\n\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test2)\n cmd()\n endmacro()\n macro(test)\n if()\n cmd()\n test2()\n cmd()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)\n self.assertEqual([], result)\n result = mock_lint(env, pkg,\n \"\"\"\n macro(test4)\n cmd()\n if()\n cmd()\n endif()\n endmacro()\n macro(test3)\n test4()\n endmacro()\n macro(test2)\n test3()\n if()\n if()\n if()\n cmd()\n test3()\n endif()\n endif()\n endif()\n endmacro()\n macro(test)\n test2()\n if()\n cmd()\n test2()\n else()\n foreach(a b c d e)\n test2()\n endforeach()\n endif()\n endmacro()\n cmd1()\n test()\n cmd3()\n \"\"\", checks=None, indentation=True)","def define_command(self, name, command):\n code = (\"function %s {\"\n \" %s \\\"$@\\\"\\n\"\n \"}\") % (name, command)\n self._printer(code)","def get_ymal_load(yamlfile):\n with open(yamlfile, 'r', encoding='utf-8') as fr:\n filedata = fr.read()\n yamldata = yaml.full_load(filedata)\n return yamldata","def __apf_cmd(cmd):\n apf_cmd = \"{} {}\".format(salt.utils.path.which(\"apf\"), cmd)\n out = __salt__[\"cmd.run_all\"](apf_cmd)\n\n if out[\"retcode\"] != 0:\n if not out[\"stderr\"]:\n msg = out[\"stdout\"]\n else:\n msg = out[\"stderr\"]\n raise CommandExecutionError(\"apf failed: {}\".format(msg))\n return out[\"stdout\"]","def run_man(self, expanded, unexpanded) : \n\t\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\n\t\tif not unexpanded :\n\t\t\tunexpanded = methodslist\n\t\tunexpanded.sort()\n\n\t\tresults = []\n\t\tfor method in unexpanded :\n\t\t\tif results :\n\t\t\t\t# more than one command to display help for\n\t\t\t\t# so we separate them in the plain text output\n\t\t\t\tself.printf(\"\\n--------\\n\\n\")\n\t\t\tif not hasattr(self, 'run_' + method) :\n\t\t\t\thelp = helphtml = \"Invalid command\"\n\t\t\telse :\n\t\t\t\thelp = getattr(self, 'run_' + method).__doc__\n\t\t\t\tif not help :\n\t\t\t\t\thelp = helphtml = \"Undocumented command\"\n\t\t\t\telse :\n\t\t\t\t\thelplines = map(string.strip, string.split(help, '\\n'))\n\t\t\t\t\thelp = string.join(helplines, '\\n')\n\t\t\t\t\thelphtml = string.join(helplines, '<br />')\n\t\t\tcommand = '<a href=\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\n\t\t\tresults.append({\"Command\": command, \"Help\": helphtml})\n\t\t\tself.printf(\"%s: %s\\n\" % (method, help))\n\t\tself.tableDisplay(\"man\", [\"Command\", \"Help\"], results)","def run_lammps(lammps_executable, input_file, output_file):\n # run lammps\n lammps_command = f\"{lammps_executable} -in {input_file} \"\n print(\"run command:\", lammps_command)\n with open(\"tmp2False.out\", \"w+\") as fout:\n subprocess.call(lammps_command.split(), stdout=fout)","def main(raw_args):\n parser = argparse.ArgumentParser()\n parser.add_argument('--module-link')\n parser.add_argument('module_path', type=os.path.realpath)\n args = parser.parse_args(raw_args)\n\n return md_module(\n load_module_from_path(args.module_path), module_link=args.module_link)","def cmd_mdtm(args):","def launch_builtin_module(cmd, args):\n\n launch_path = \"%s/core/cmds/%s.py\" % (utils.get_pydtf_dir(), cmd)\n\n return __launch_python_module(launch_path, cmd, args)","def manage(ctx, user_cmd):\n ScalingoInterface(ctx.obj).manage_py(user_cmd)","def _magic_docs(self, brief=False, rest=False):\n mman = self.shell.magics_manager\n docs = mman.lsmagic_docs(brief, missing='No documentation')\n\n if rest:\n format_string = '**%s%s**::\\n\\n%s\\n\\n'\n else:\n format_string = '%s%s:\\n%s\\n'\n\n return ''.join(\n [format_string % (magic_escapes['line'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['line'].items())]\n +\n [format_string % (magic_escapes['cell'], fname,\n indent(dedent(fndoc)))\n for fname, fndoc in sorted(docs['cell'].items())]\n )","def lammps(step, atomnum, boxbounds, addson = ''):\r\n\r\n line = 'ITEM: TIMESTEP\\n'\r\n line += str(step) + '\\n'\r\n\r\n line += 'ITEM: NUMBER OF ATOMS\\n'\r\n line += str(atomnum) + '\\n'\r\n\r\n line += 'ITEM: BOX BOUNDS pp pp pp\\n'\r\n line += '%.6f %.6f\\n' %(boxbounds[0, 0], boxbounds[0, 1])\r\n line += '%.6f %.6f\\n' %(boxbounds[1, 0], boxbounds[1, 1])\r\n if boxbounds.shape[0] == 3:\r\n line += '%.6f %.6f\\n' %(boxbounds[2, 0], boxbounds[2, 1])\r\n else:\r\n line += '%.6f %.6f\\n' %(-0.5, 0.5)\r\n\r\n line += 'ITEM: ATOMS id type x y z %s\\n' %addson\r\n\r\n return line","def stringSmuMod(self, arg):\n\t\targ[0] = \"'\" + arg[0] + \"'\"\n\t\targ[2] = \"'\" + arg[2] + \"'\"\n\t\treturn arg","def set_action_cmd(self, action):\n if self.args.snapcheck is True:\n action = \"snapcheck\"\n if self.args.check is True:\n action = \"check\"\n if self.args.snap is True:\n action = \"snap\"\n if self.args.diff is True:\n action = \"diff\"\n return action","async def manga(self, ctx: commands.Context) -> None:\n if ctx.invoked_subcommand is None:\n if ctx.subcommand_passed is None:\n # There is no subcommand: inform the user about the manga reader.\n summary = \"\"\"Hi! Welcome to Bakerbot's manga reader.\n This cog houses commands for searching and reading manga.\n See `$help mangadex` for a full list of available subcommands.\"\"\"\n\n embed = utilities.Embeds.standard()\n embed.set_footer(text=\"Powered by the Mangadex API.\", icon_url=utilities.Icons.info)\n embed.description = summary\n await ctx.reply(embed=embed)\n else:\n # The subcommand was not valid: throw a fit.\n command = f\"${ctx.command.name} {ctx.subcommand_passed}\"\n summary = f\"`{command}` is not a valid command.\"\n footer = \"Try $help mangadex for a full list of available subcommands.\"\n embed = utilities.Embeds.status(False, summary)\n embed.set_footer(text=footer, icon_url=utilities.Icons.cross)\n await ctx.reply(embed=embed)","def cmd(self, cmd):\n return cmd","def magic_ld(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep /$')","def ipmagic(arg_s):\n\n args = arg_s.split(' ',1)\n magic_name = args[0]\n if magic_name.startswith(__IPYTHON__.ESC_MAGIC):\n magic_name = magic_name[1:]\n try:\n magic_args = args[1]\n except IndexError:\n magic_args = ''\n fn = getattr(__IPYTHON__,'magic_'+magic_name,None)\n if fn is None:\n error(\"Magic function `%s` not found.\" % magic_name)\n else:\n magic_args = __IPYTHON__.var_expand(magic_args)\n return fn(magic_args)","def add_cmd(self, cmd, name=\"\"):\n if cmd:\n self.cmds.add((cmd, name))","def cmd_creator():\n return OpenMayaMPx.asMPxPtr(AzureBatchSetup())","def sub_command(self):\n self.write(\"@SP\\nAM=M-1\\nD=M\\nA=A-1\\nM=M-D\\n\")","def lemma(self) -> str:","def podman(self, command: Command, **kwargs: Any) -> tmt.utils.CommandOutput:\n return self.run(Command('podman') + command, **kwargs)","def _mafft(exe, seq, outfile):\n \n args = [exe, '--quiet', seq]\n try:\n with open(outfile, 'w') as stdout:\n process = Popen(args, stdout=stdout, stderr=PIPE,\n universal_newlines=True)\n code = process.wait()\n except OSError:\n msg = 'Failed to write alignment to outfile {}'.format(outfile)\n error('Aligning sequence: {} via MUSCLE failed due to:\\n\\tIOError, '\n 'failed to write alignment to outfile: {}.'.format(seq, outfile))\n sys.exit(1)\n if code:\n if os.path.isfile(outfile):\n os.remove(outfile)\n msg = indent(process.stderr.read(), prefix='\\t')\n process.stderr.close()\n error('Aligning sequence: {} via MAFFT failed due to:\\n{}.'.format(seq,\n msg))\n sys.exit(1)\n \n return outfile","def magic_r(self, parameter_s=''):\n\n start = parameter_s.strip()\n # Identify magic commands even if automagic is on (which means\n # the in-memory version is different from that typed by the user).\n if self.shell.rc.automagic:\n start_magic = '@'+start\n else:\n start_magic = start\n # Look through the input history in reverse\n for n in range(len(self.shell.input_hist)-2,0,-1):\n input = self.shell.input_hist[n]\n if input.startswith('#@'):\n input = input[1:]\n if input != '@r\\n' and \\\n (input.startswith(start) or input.startswith(start_magic)):\n #print 'match',`input` # dbg\n if input.startswith('@'):\n input = magic2python(input)\n #print 'modified',`input` # dbg\n print 'Executing:',input,\n exec input in self.shell.user_ns\n return\n print 'No previous input matching `%s` found.' % start","def command_(self, name):\n def decorator(func):\n func.__name__ = name\n return self.command(func)\n return decorator","def run(md_file, interact):\n lines = open(md_file, 'r').readlines()\n blocks = extract_blocks(lines)\n run_py(blocks, interact=interact)","def magic_lf(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^-')","def help_load(self):\n help_str = \"\"\"Runs commands in script at file or URL.\n\n Usage: load [file_path]\n\n optional argument:\n file_path - a file path or URL pointing to a script (default: value stored in `default_file_name` parameter)\n\nScript should contain one command per line, just like command would be typed in console.\"\"\"\n self.stdout.write(\"{}\\n\".format(help_str))","def ap(self) -> str:\n return self.raw(\"ap\", \"\")","def usage():\n print \"\"\"\nUsages:\n ./lmf-merger.py -m file1 file2 outfile\n ./lmf-merger.py -s file1 ...\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\n \"\"\"","def __init__(self,cmds):\n\n # Since the list may include multi-line entries, first make sure that\n # they've been all broken up before passing it to magic2python\n cmdlist = map(magic2python,''.join(cmds).split('\\n'))\n self.value = '\\n'.join(cmdlist)","def lemmatize_verbs(self):\n lemmas = []\n # lemmas = \"\"\n for word in self.words:\n lemma = wn.lemmatize(word, pos='v')\n lemmas.append(lemma)\n # lemmas += f\"{lemma} \"\n self.words = lemmas\n return self","def menu_help(cls, **attr):\n menu_help = MM(\"Help\", c=\"default\", f=\"help\", **attr)(\n MM(\"Contact us\", f=\"contact\"),\n MM(\"About\", f=\"about\"),\n MM(current.T(\"Ask MSW\"), c=\"org\", f=\"ask_msw\"),\n MM(\"spiegel.de\", c=\"org\", f=\"spiegel\"),\n )\n return menu_help","def manage_py(self, management_command_name, **options):\n cmd = f\"python manage.py {management_command_name}\"\n for name, val in options.items():\n cmd += f\" --{name} {val}\"\n self.run(cmd)","def add_command(self, name, fct):\r\n self.cmds[name] = fct","def use_mfa_secret_from_vault(\n self, vault_name: str, vault_key: str, mode: OTPMode = OTPMode.TIME\n ):\n secrets = Vault().get_secret(vault_name)\n if mode == OTPMode.TIME:\n self.set_time_based_otp(secrets[vault_key])\n elif mode == OTPMode.COUNTER:\n self.set_counter_based_otp(secrets[vault_key])","def _build_simple_command(self, cmd):\n return cmd+SBE37_NEWLINE","def help_util():\r\n for cmd, f in COMMANDS.items():\r\n print(\"POM \" + cmd + \":\")\r\n print(f.__doc__.lstrip(\"\\n\"))","def mafft(inputseqfile, outputmsafile):\n \n command_msa = 'mafft --retree 2 --reorder ' + inputseqfile + ' > ' + outputmsafile\n os.system(command_msa)\n #os.system(\"mafft --retree 2 --reorder ks.fasta > ks.mafft.fasta\")\n #subprocess.call(['mafft --retree 2 --reorder', 'ks.fasta', '>', 'ks.mafft.fasta']) not currently working","def do_ls(self, line):\n print(self.name, 'do---')","def fusion_generate_mmmc_script(x: hammer_vlsi.HammerTool) -> str:\n mmmc_output = [] # type: List[str]\n\n def append_mmmc(cmd: str) -> None:\n x.verbose_tcl_append(cmd, mmmc_output)\n\n # Create an Innovus constraint mode.\n constraint_mode = \"my_constraint_mode\"\n sdc_files = [] # type: List[str]\n\n # Generate constraints\n clock_constraints_fragment = os.path.join(x.run_dir, \"clock_constraints_fragment.sdc\")\n with open(clock_constraints_fragment, \"w\") as f:\n f.write(x.sdc_clock_constraints)\n sdc_files.append(clock_constraints_fragment)\n\n # Generate port constraints.\n pin_constraints_fragment = os.path.join(x.run_dir, \"pin_constraints_fragment.sdc\")\n with open(pin_constraints_fragment, \"w\") as f:\n f.write(x.sdc_pin_constraints)\n sdc_files.append(pin_constraints_fragment)\n\n # Add the post-synthesis SDC, if present.\n post_synth_sdc = x.post_synth_sdc\n if post_synth_sdc is not None:\n sdc_files.append(post_synth_sdc)\n\n # TODO: add floorplanning SDC\n if len(sdc_files) > 0:\n sdc_files_arg = \"-sdc_files [list {sdc_files}]\".format(\n sdc_files=\" \".join(sdc_files)\n )\n else:\n blank_sdc = os.path.join(x.run_dir, \"blank.sdc\")\n x.run_executable([\"touch\", blank_sdc])\n sdc_files_arg = \"-sdc_files {{ {} }}\".format(blank_sdc)\n append_mmmc(\"create_constraint_mode -name {name} {sdc_files_arg}\".format(\n name=constraint_mode,\n sdc_files_arg=sdc_files_arg\n ))\n\n corners = x.get_mmmc_corners() # type: List[MMMCCorner]\n # In parallel, create the delay corners\n if corners:\n setup_corner = corners[0] # type: MMMCCorner\n hold_corner = corners[0] # type: MMMCCorner\n pwr_corner = corners[0] # type: MMMCCorner\n # TODO(colins): handle more than one corner and do something with extra corners\n for corner in corners:\n if corner.type is MMMCCornerType.Setup:\n setup_corner = corner\n if corner.type is MMMCCornerType.Hold:\n hold_corner = corner\n if corner.type is MMMCCornerType.Extra:\n pwr_corner = corner\n\n # First, create Innovus library sets\n append_mmmc(\"create_library_set -name {name} -timing [list {list}]\".format(\n name=\"{n}.setup_set\".format(n=setup_corner.name),\n list=x.get_timing_libs(setup_corner)\n ))\n append_mmmc(\"create_library_set -name {name} -timing [list {list}]\".format(\n name=\"{n}.hold_set\".format(n=hold_corner.name),\n list=x.get_timing_libs(hold_corner)\n ))\n append_mmmc(\"create_library_set -name {name} -timing [list {list}]\".format(\n name=\"{n}.pwr_set\".format(n=pwr_corner.name),\n list=x.get_timing_libs(pwr_corner)\n ))\n # Skip opconds for now\n # Next, create Innovus timing conditions\n append_mmmc(\"create_timing_condition -name {name} -library_sets [list {list}]\".format(\n name=\"{n}.setup_cond\".format(n=setup_corner.name),\n list=\"{n}.setup_set\".format(n=setup_corner.name)\n ))\n append_mmmc(\"create_timing_condition -name {name} -library_sets [list {list}]\".format(\n name=\"{n}.hold_cond\".format(n=hold_corner.name),\n list=\"{n}.hold_set\".format(n=hold_corner.name)\n ))\n append_mmmc(\"create_timing_condition -name {name} -library_sets [list {list}]\".format(\n name=\"{n}.pwr_cond\".format(n=pwr_corner.name),\n list=\"{n}.pwr_set\".format(n=pwr_corner.name)\n ))\n # Next, create Innovus rc corners from qrc tech files\n append_mmmc(\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\".format(\n name=\"{n}.setup_rc\".format(n=setup_corner.name),\n tempInCelsius=str(setup_corner.temp.value),\n qrc=\"-qrc_tech {}\".format(x.get_mmmc_qrc(setup_corner)) if x.get_mmmc_qrc(setup_corner) != '' else ''\n ))\n append_mmmc(\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\".format(\n name=\"{n}.hold_rc\".format(n=hold_corner.name),\n tempInCelsius=str(hold_corner.temp.value),\n qrc=\"-qrc_tech {}\".format(x.get_mmmc_qrc(hold_corner)) if x.get_mmmc_qrc(hold_corner) != '' else ''\n ))\n append_mmmc(\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\".format(\n name=\"{n}.pwr_rc\".format(n=pwr_corner.name),\n tempInCelsius=str(pwr_corner.temp.value),\n qrc=\"-qrc_tech {}\".format(x.get_mmmc_qrc(pwr_corner)) if x.get_mmmc_qrc(pwr_corner) != '' else ''\n ))\n # Next, create an Innovus delay corner.\n append_mmmc(\n \"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\".format(\n name=\"{n}.setup\".format(n=setup_corner.name)\n ))\n append_mmmc(\n \"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\".format(\n name=\"{n}.hold\".format(n=hold_corner.name)\n ))\n append_mmmc(\n \"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\".format(\n name=\"{n}.pwr\".format(n=pwr_corner.name)\n ))\n # Next, create the analysis views\n append_mmmc(\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\".format(\n name=\"{n}.setup\".format(n=setup_corner.name), constraint=constraint_mode))\n append_mmmc(\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\".format(\n name=\"{n}.hold\".format(n=hold_corner.name), constraint=constraint_mode))\n append_mmmc(\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\".format(\n name=\"{n}.pwr\".format(n=pwr_corner.name), constraint=constraint_mode))\n # Finally, apply the analysis view.\n append_mmmc(\"set_analysis_view -setup {{ {setup_view} }} -hold {{ {hold_view} }} -leakage {{ {pwr_view} }} -dynamic {{ {pwr_view} }}\".format(\n setup_view=\"{n}.setup_view\".format(n=setup_corner.name),\n hold_view=\"{n}.hold_view\".format(n=hold_corner.name),\n pwr_view=\"{n}.pwr_view\".format(n=pwr_corner.name)\n ))\n else:\n # First, create an Innovus library set.\n library_set_name = \"my_lib_set\"\n append_mmmc(\"create_library_set -name {name} -timing [list {list}]\".format(\n name=library_set_name,\n list=x.get_timing_libs()\n ))\n # Next, create an Innovus timing condition.\n timing_condition_name = \"my_timing_condition\"\n append_mmmc(\"create_timing_condition -name {name} -library_sets [list {list}]\".format(\n name=timing_condition_name,\n list=library_set_name\n ))\n # extra junk: -opcond ...\n rc_corner_name = \"rc_cond\"\n append_mmmc(\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\".format(\n name=rc_corner_name,\n tempInCelsius=120, # TODO: this should come from tech config\n qrc=\"-qrc_tech {}\".format(x.get_qrc_tech()) if x.get_qrc_tech() != '' else ''\n ))\n # Next, create an Innovus delay corner.\n delay_corner_name = \"my_delay_corner\"\n append_mmmc(\n \"create_delay_corner -name {name} -timing_condition {timing_cond} -rc_corner {rc}\".format(\n name=delay_corner_name,\n timing_cond=timing_condition_name,\n rc=rc_corner_name\n ))\n # extra junk: -rc_corner my_rc_corner_maybe_worst\n # Next, create an Innovus analysis view.\n analysis_view_name = \"my_view\"\n append_mmmc(\"create_analysis_view -name {name} -delay_corner {corner} -constraint_mode {constraint}\".format(\n name=analysis_view_name, corner=delay_corner_name, constraint=constraint_mode))\n # Finally, apply the analysis view.\n # TODO: introduce different views of setup/hold and true multi-corner\n append_mmmc(\"set_analysis_view -setup {{ {setup_view} }} -hold {{ {hold_view} }}\".format(\n setup_view=analysis_view_name,\n hold_view=analysis_view_name\n ))\n\n return \"\\n\".join(mmmc_output)","def list_param(command):\n namespace = app.main(command)\n assert namespace.command == 'lp' or namespace.command == \"listparam\"","def run_lap():\n pass","def libmagic(self):\n return self.tag(\"libmagic\")","def label(cmd):\r\n cmd = cmd.replace('make][.DP', 'make1][.NP')\r\n cmd = cmd.replace('make][.SC', 'make2][.SC')\r\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\r\n cmd = '[result ' + cmd + ']' #dummy function for plop\r\n return cmd","def modulecmds():\n\n class Commands:\n @staticmethod\n def setenv(key, val=None):\n val = val or key\n return \"setenv({0!r}, {1!r})\\n\".format(key, val)\n\n @staticmethod\n def unsetenv(key):\n return \"unsetenv({0!r})\\n\".format(key)\n\n @staticmethod\n def load(x):\n return \"load({0!r})\\n\".format(x)\n\n @staticmethod\n def load_first(*x):\n x = \",\".join(\"{0!r}\".format(_) for _ in x)\n return \"load_first({0})\\n\".format(x)\n\n @staticmethod\n def unload(x):\n return \"unload({0!r})\\n\".format(x)\n\n @staticmethod\n def prepend_path(key, val=None, sep=os.pathsep):\n val = val or key\n return \"prepend_path({0!r},{1!r},sep={2!r})\\n\".format(key, val, sep)\n\n @staticmethod\n def append_path(key, val=None, sep=os.pathsep):\n val = val or key\n return \"append_path({0!r},{1!r},sep={2!r})\\n\".format(key, val, sep)\n\n @staticmethod\n def remove_path(key, val=None, sep=os.pathsep):\n val = val or key\n return \"remove_path({0!r},{1!r},sep={2!r})\\n\".format(key, val, sep)\n\n @staticmethod\n def set_alias(key, val):\n return \"set_alias({0!r},{1!r})\\n\".format(key, val)\n\n @staticmethod\n def unset_alias(key):\n return \"unset_alias({0!r})\\n\".format(key)\n\n @staticmethod\n def set_shell_function(key, val):\n return \"set_shell_function({0!r},{1!r})\\n\".format(key, val)\n\n @staticmethod\n def unset_shell_function(key):\n return \"unset_shell_function({0!r})\\n\".format(key)\n\n @staticmethod\n def use(path):\n return \"use({0!r})\\n\".format(path)\n\n @staticmethod\n def unuse(path):\n return \"unuse({0!r})\\n\".format(path)\n\n @staticmethod\n def swap(a, b):\n return \"swap({0!r}, {1!r})\\n\".format(a, b)\n\n @staticmethod\n def family(x):\n return \"family({0!r})\\n\".format(x)\n\n @staticmethod\n def conflict(x):\n return \"conflict({0!r})\\n\".format(x)\n\n @staticmethod\n def prereq(x):\n return \"prereq({0!r})\\n\".format(x)\n\n @staticmethod\n def prereq_any(*x):\n x = \",\".join(\"{0!r}\".format(_) for _ in x)\n return \"prereq_any({0})\\n\".format(x)\n\n @staticmethod\n def source(f):\n return \"source({0!r})\\n\".format(f)\n\n @staticmethod\n def help(x):\n return \"help({0!r})\\n\".format(x)\n\n @staticmethod\n def whatis(x):\n return \"whatis({0!r})\\n\".format(x)\n\n @staticmethod\n def isloaded(x):\n return \"is_loaded({0!r})\\n\".format(x)\n\n return Commands()","def _opm(command, runas=None):\n cmdline = [\"opm\"] + command\n ret = __salt__[\"cmd.run_all\"](cmdline, runas=runas, python_shell=False)\n\n if ret[\"retcode\"] == 0:\n return ret[\"stdout\"]\n\n raise CommandExecutionError(ret[\"stderr\"])","def edit_ruleset(command):\n namespace = app.main(command)\n assert namespace.command == 'er' or namespace.command == \"editruleset\"\n assert namespace.name == \"test\"\n assert namespace.action in ['a','d']","def magic_automagic(self, parameter_s = ''):\n \n self.rc.automagic = 1 - self.rc.automagic\n print '\\n' + Magic.auto_status[self.rc.automagic]","def test_matmul_mm(self):\n self.check_dot_mm(matmul_usecase, None, \"'@'\")","def lt_command(self):\n self.write(\n \"@SP\\nA=M-1\\nD=M\\n@NEG1\" + str(\n self.__label_num) + \"\\nD;JLT\\n@POS1\" + str(\n self.__label_num) +\n \"\\nD;JGE\\n(NEG1\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nA=A-1\\nD=M\\n@POS2\" + str(\n self.__label_num) + \"\\nD;JGT\\n@CONT\"\n + str(self.__label_num) + \"\\n0;JMP\\n(POS1\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nA=A-1\\nD=M\\n@NEG2\" +\n str(self.__label_num) + \"\\nD;JLT\\n@CONT\" + str(\n self.__label_num) + \"\\n0;JMP\\n(POS2\" + str(\n self.__label_num) + \")\\n@SP\"\n \"\\nA=M-1\\nA=A-1\\nM=0\\n@SP\\nM=M-1\\n@ENDLABEL\" + str(\n self.__label_num) + \"\\n0;JMP\\n(NEG2\" + str(\n self.__label_num) + \")\\n@SP\" +\n \"\\nA=M-1\\nA=A-1\\nM=-1\\n@SP\\nM=M-1\\n@ENDLABEL\" + str(\n self.__label_num) + \"\\n0;JMP\\n(CONT\" + str(\n self.__label_num) + \")\\n\"\n \"@SP\\nM=M-1\\nA=M\\nD=M\\n@SP\\nA=M-1\\nD=M-D\\n@TRUE\" + str(\n self.__label_num) + \"\\nD;JGE\\n@SP\\nA=M-1\\nM=-1\\n@ENDLABEL\" +\n str(self.__label_num) + \"\\n0;JMP\\n(TRUE\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nM=0\\n(ENDLABEL\" +\n str(self.__label_num) + \")\\n\")","def _handleAnchor(self):\n if self._lastCommand == \"M\":\n self._commands.pop(-1)","def extendMarkdown(self, md, md_globals):\r\n md.inlinePatterns['autolink'] = UrlizePattern(URLIZE_RE, md)","def lammpsdata(atomnum, atomtypes, boxbounds):\r\n\r\n line = '#LAMMPS data file\\n\\n'\r\n line += '%d atoms\\n' %(atomnum)\r\n line += '%d atom types\\n\\n' %(atomtypes)\r\n line += '%.6f %.6f xlo xhi\\n' %(boxbounds[0, 0], boxbounds[0, 1])\r\n line += '%.6f %.6f ylo yhi\\n' %(boxbounds[1, 0], boxbounds[1, 1])\r\n line += '%.6f %.6f zlo zhi\\n' %(boxbounds[2, 0], boxbounds[2, 1])\r\n line += '\\nAtoms #atomic\\n'\r\n\r\n return line","def vim_normal_mode_exterm_key(cmd: str):\n v = VimMode()\n v.set_normal_mode_exterm()\n actions.key(cmd)","def define_command(self, name, command):\n code = (\"function %s {\"\n \" %s $args\\n\"\n \" $status = $?\\n\"\n \" If ($status -eq 0) {\\n\"\n \" exit 1\\n\"\n \" }\\n\"\n \"}\") % (name, command)\n self._printer(code)","def register_command(app: MaraApp, command: click.Command, package: str):\n if isinstance(command, click.MultiCommand):\n app.cli.add_command(command)\n else:\n command.name = package + '.' + command.name\n app.cli.add_command(command)","def parseargs(p):\n p.set_defaults(func=func)\n p.description = \"Print machine architecture.\"\n return p","def set_linker_script(self, op):\n self.__linker_script = [\"-T\", op]","def role_command():","def label(cmd):\n cmd = cmd.replace('make][.DP', 'make1][.NP')\n cmd = cmd.replace('make][.SC', 'make2][.SC')\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\n cmd = '[result ' + cmd + ']' #dummy function for plop\n return cmd","def form_m(orig: Symbol):\n return _decor_base(orig, lambda _: 'm')","def cmd(self, cmd):\n\n self._cmd = cmd"],"string":"[\n \"def maml_parser():\\n parser = MagicCommandParser(prog=\\\"maml\\\",\\n description='Runs a maml script.')\\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\\n help='hide output')\\n return parser\",\n \"def command(self,cmd):\\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))\",\n \"def command(self, cmd):\\n self.lmp.command(cmd)\",\n \"def magic_lsmagic(self, parameter_s = ''):\\n print 'Available magic functions:\\\\n@'+' @'.join(self.lsmagic())\\n print '\\\\n' + Magic.auto_status[self.rc.automagic]\\n return None\",\n \"def magic_magic(self, parameter_s = ''):\\n\\n mode = ''\\n try:\\n if parameter_s.split()[0] == '-latex':\\n mode = 'latex'\\n except:\\n pass\\n\\n magic_docs = []\\n for fname in self.lsmagic():\\n mname = 'magic_' + fname\\n for space in (Magic,self,self.__class__):\\n try:\\n fn = space.__dict__[mname]\\n except KeyError:\\n pass\\n else:\\n break\\n magic_docs.append('@%s:\\\\n\\\\t%s\\\\n' %(fname,fn.__doc__))\\n magic_docs = ''.join(magic_docs)\\n\\n if mode == 'latex':\\n print self.format_latex(magic_docs)\\n return\\n else:\\n magic_docs = self.format_screen(magic_docs)\\n \\n outmsg = \\\"\\\"\\\"\\nIPython's 'magic' functions\\n===========================\\n\\nThe magic function system provides a series of functions which allow you to\\ncontrol the behavior of IPython itself, plus a lot of system-type\\nfeatures. All these functions are prefixed with a @ character, but parameters\\nare given without parentheses or quotes.\\n\\nExample: typing '@cd mydir' (without the quotes) changes you working directory\\nto 'mydir', if it exists.\\n\\nIf you have 'automagic' enabled (via the command line option or with the\\n@automagic function), you don't need to type in the @ explicitly.\\n\\nYou can define your own magic functions to extend the system. See the supplied\\nipythonrc and example-magic.py files for details (in your ipython\\nconfiguration directory, typically $HOME/.ipython/).\\n\\nYou can also define your own aliased names for magic functions. In your\\nipythonrc file, placing a line like:\\n\\n execute __IP.magic_cl = __IP.magic_clear\\n\\nwill define @cl as a new name for @clear.\\n\\nFor a list of the available magic functions, use @lsmagic. For a description\\nof any of them, type @magic_name?.\\n\\nCurrently the magic system has the following functions:\\\\n\\\"\\\"\\\"\\n\\n outmsg = (\\\"%s\\\\n%s\\\\n\\\\nSummary of magic functions (from @lsmagic):\\\"\\n \\\"\\\\n\\\\n@%s\\\\n\\\\n%s\\\" % (outmsg,\\n magic_docs,\\n ' @'.join(self.lsmagic()),\\n Magic.auto_status[self.rc.automagic] ) )\\n\\n page(outmsg,screen_lines=self.rc.screen_length)\",\n \"def handle_magic(self, line, continue_prompt=None,\\n pre=None,iFun=None,theRest=None):\\n\\n cmd = '%sipmagic(\\\"%s\\\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\\n self.log(cmd,continue_prompt)\\n self.update_cache(line)\\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\\n return cmd\",\n \"def man(command):\\n\\tspeech.speak(\\\"Executing 'man \\\" + command + \\\"' to show you documentation for this command.\\\")\\n\\tsubprocess.call([\\\"man\\\", command])\",\n \"def maml(self, maml: List[PredictionsDatapoints]):\\n\\n self._maml = maml\",\n \"def set_m(self, varname: str, varval: Optional[str]) -> None:\\n if varname:\\n self.pandoc.append('-M')\\n self.pandoc.append(f'{varname}={varval}')\",\n \"def magic2python(cmd):\\n\\n if cmd.startswith('#@') or cmd.startswith('@'):\\n if cmd[0]=='#':\\n cmd = cmd[1:]\\n # we need to return the proper line end later\\n if cmd[-1] == '\\\\n':\\n endl = '\\\\n'\\n else:\\n endl = ''\\n try:\\n func,args = cmd[1:].split(' ',1)\\n except:\\n func,args = cmd[1:].rstrip(),''\\n args = args.replace('\\\"','\\\\\\\\\\\"').replace(\\\"'\\\",\\\"\\\\\\\\'\\\").rstrip()\\n return '__IP.magic_%s (\\\"%s\\\")%s' % (func,args,endl)\\n else:\\n return cmd\",\n \"def niw_mmml_mp(args):\\n return niw_mmml(*args)\",\n \"def _make_matlab_command(self):\\n \\n raise NotImplementedError\",\n \"def magic(self, parameter_s=''):\\n\\n mode = ''\\n try:\\n mode = parameter_s.split()[0][1:]\\n except IndexError:\\n pass\\n\\n brief = (mode == 'brief')\\n rest = (mode == 'rest')\\n magic_docs = self._magic_docs(brief, rest)\\n\\n if mode == 'latex':\\n print(self.format_latex(magic_docs))\\n return\\n else:\\n magic_docs = format_screen(magic_docs)\\n\\n out = [\\\"\\\"\\\"\\nIPython's 'magic' functions\\n===========================\\n\\nThe magic function system provides a series of functions which allow you to\\ncontrol the behavior of IPython itself, plus a lot of system-type\\nfeatures. There are two kinds of magics, line-oriented and cell-oriented.\\n\\nLine magics are prefixed with the % character and work much like OS\\ncommand-line calls: they get as an argument the rest of the line, where\\narguments are passed without parentheses or quotes. For example, this will\\ntime the given statement::\\n\\n %timeit range(1000)\\n\\nCell magics are prefixed with a double %%, and they are functions that get as\\nan argument not only the rest of the line, but also the lines below it in a\\nseparate argument. These magics are called with two arguments: the rest of the\\ncall line and the body of the cell, consisting of the lines below the first.\\nFor example::\\n\\n %%timeit x = numpy.random.randn((100, 100))\\n numpy.linalg.svd(x)\\n\\nwill time the execution of the numpy svd routine, running the assignment of x\\nas part of the setup phase, which is not timed.\\n\\nIn a line-oriented client (the terminal or Qt console IPython), starting a new\\ninput with %% will automatically enter cell mode, and IPython will continue\\nreading input until a blank line is given. In the notebook, simply type the\\nwhole cell as one entity, but keep in mind that the %% escape can only be at\\nthe very start of the cell.\\n\\nNOTE: If you have 'automagic' enabled (via the command line option or with the\\n%automagic function), you don't need to type in the % explicitly for line\\nmagics; cell magics always require an explicit '%%' escape. By default,\\nIPython ships with automagic on, so you should only rarely need the % escape.\\n\\nExample: typing '%cd mydir' (without the quotes) changes your working directory\\nto 'mydir', if it exists.\\n\\nFor a list of the available magic functions, use %lsmagic. For a description\\nof any of them, type %magic_name?, e.g. '%cd?'.\\n\\nCurrently the magic system has the following functions:\\\"\\\"\\\",\\n magic_docs,\\n \\\"Summary of magic functions (from %slsmagic):\\\" % magic_escapes['line'],\\n str(self.lsmagic()),\\n ]\\n page.page('\\\\n'.join(out))\",\n \"async def man(self, ctx: Context, *, command: str) -> None:\\n base_query = f\\\"https://www.mankier.com/api/v2/mans/?q={command}\\\"\\n query_url = urllib.parse.quote_plus(base_query, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n async with ctx.typing():\\n # Get API query responses\\n async with self.session.get(query_url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n results = json.loads(await response.text())[\\\"results\\\"]\\n\\n # Use first result\\n if len(results) > 0:\\n result = results[0]\\n else:\\n await ctx.send(\\\"Invalid query, no such command\\\")\\n return\\n\\n base_url = f\\\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\\\"\\n url = urllib.parse.quote_plus(base_url, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n # Load man page from first result\\n async with self.session.get(url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n result = json.loads(await response.text())\\n\\n embed = Embed(\\n title=f\\\"Man page of: **{result['name'].capitalize()}**\\\",\\n url=result[\\\"url\\\"],\\n description=f\\\"**{result['description']}** ({result['section']})\\\"\\n )\\n\\n for anchor in result['anchors']:\\n embed.add_field(\\n name=f\\\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\\\",\\n value=f\\\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\\\n[Link here]({anchor['url']})\\\",\\n inline=False\\n )\\n # TODO: Solve this with pagination\\n try:\\n await ctx.send(embed=embed)\\n except HTTPException as e:\\n if e.code == 50035:\\n await ctx.send(embed=Embed(\\n description=\\\"Body is too long to show\\\",\\n color=Color.red()\\n ))\\n else:\\n raise e\",\n \"def magic_ll(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^l')\",\n \"def mlnet_parser():\\n parser = MagicCommandParser(prog=\\\"mlnet\\\",\\n description='Compiles and wrap a C# function into a Python function.\\\\n'\\n 'Automatically adds ML.net dependencies.')\\n parser.add_argument('name', type=str, help='function name')\\n parser.add_argument('-i', '--idep', nargs='*', action='append',\\n help='internal dependencies (like System, System.Linq)')\\n parser.add_argument('-d', '--dep', nargs='*', action='append',\\n help='dependencies (assembly name without extension)')\\n parser.add_argument('-c', '--catch', action='store', default=False,\\n help='catch exception')\\n return parser\",\n \"def _llm_type(self) -> str:\\n return \\\"llama.cpp\\\"\",\n \"def getArbitraryManInput(self):\\n return \\\"\\\"\\\".TH MANHOLE \\\"1\\\" \\\"August 2001\\\" \\\"\\\" \\\"\\\"\\n.SH NAME\\nmanhole \\\\- Connect to a Twisted Manhole service\\n.SH SYNOPSIS\\n.B manhole\\n.SH DESCRIPTION\\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\\ncode as if at an interactive Python console inside a running Twisted process\\nwith this.\\\"\\\"\\\"\",\n \"def yamlmain(argv=None):\\n if argv is None:\\n argv = sys.argv\\n if len(argv) == 1:\\n _fullusage()\\n try:\\n command = argv[1]\\n if command in ['get', 'dump']:\\n _rosparam_cmd_get_dump(command, argv)\\n elif command in ['set', 'load']:\\n _rosparam_cmd_set_load(command, argv)\\n elif command in ['delete']:\\n _rosparam_cmd_delete(argv)\\n elif command == 'list':\\n _rosparam_cmd_list(argv)\\n else:\\n _fullusage()\\n except RosParamException as e:\\n print(\\\"ERROR: \\\"+str(e), file=sys.stderr)\\n sys.exit(1)\",\n \"def add_command(self):\\n self.write(\\\"@SP\\\\nAM=M-1\\\\nD=M\\\\nA=A-1\\\\nM=M+D\\\\n\\\")\",\n \"def __getattr__(self, item):\\n if item not in _CommandsMetaClass.commands_dict:\\n raise MPDCommandNotExists(\\\"no such command: '{}'\\\".format(item))\\n\\n f = lambda *args: \\\"{} {}\\\\n\\\".format(item, ' '.join(_CommandsMetaClass._quote_arguments(args)))\\n f.__doc__ = \\\"Command's Arguments: {}\\\".format(_CommandsMetaClass.commands_dict[item])\\n f.__name__ = item\\n return f\",\n \"def magic_alias(self, parameter_s = ''):\\n\\n par = parameter_s.strip()\\n if not par:\\n if self.rc.automagic:\\n prechar = ''\\n else:\\n prechar = '@'\\n print 'Alias\\\\t\\\\tSystem Command\\\\n'+'-'*30\\n aliases = self.alias_table.keys()\\n aliases.sort()\\n for alias in aliases:\\n print prechar+alias+'\\\\t\\\\t'+self.alias_table[alias]\\n return\\n try:\\n alias,cmd = par.split(' ',1)\\n except:\\n print inspect.getdoc(self.magic_alias)\\n return\\n nargs = cmd.count('%s')\\n if nargs == 0: # simple aliases\\n fndef = itpl(\\n\\\"\\\"\\\"\\ndef magic_${alias}(parameter_s = ''):\\n '''Alias to the system command '$cmd' '''\\n xsys('$cmd '+str(parameter_s))\\n\\nself.magic_$alias = magic_$alias\\n\\\"\\\"\\\")\\n else: # parametric aliases\\n fndef = itpl(\\n\\\"\\\"\\\"\\ndef magic_${alias}(parameter_s = ''):\\n '''Alias to the system command '$cmd' '''\\n cmd = '$cmd'\\n nargs = cmd.count('%s')\\n args = str(parameter_s).split()\\n\\n if len(args) != nargs:\\n print 'Incorrect number of arguments:',nargs,'expected.'\\n print \\\"$alias is an alias to: '$cmd'\\\"\\n return\\n else:\\n cmd_call = cmd % tuple(args)\\n xsys(cmd_call)\\n\\nself.magic_$alias = magic_$alias\\n\\\"\\\"\\\")\\n try:\\n exec fndef in globals(),locals()\\n except:\\n print self.magic_alias.__doc__\\n self.alias_table.update({alias:cmd})\",\n \"def cmd(name: str) -> Callable:\\n return g.new_cmd_decorator(name, ['c', 'spellCommands',])\",\n \"def yamllint(context):\\n exec_cmd = \\\"yamllint .\\\"\\n run_cmd(context, exec_cmd)\",\n \"def magic_macro(self,parameter_s = ''):\\n\\n args = parameter_s.split()\\n name,ranges = args[0], args[1:]\\n #print 'rng',ranges # dbg\\n cmds = self.extract_input_slices(ranges)\\n macro = Macro(cmds)\\n self.user_ns.update({name:macro})\\n print 'Macro `%s` created. To execute, type its name (without quotes).' % name\\n print 'Macro contents:'\\n print str(macro).rstrip(),\",\n \"def magic(self, alias):\\n if alias in self.aliases:\\n return self.aliases[alias]\\n else:\\n return \\\"%%{}\\\\n\\\".format(alias)\",\n \"def doautocmd(self, *autocmds):\\n self._vim.command('doautocmd ' + ','.join(autocmds))\",\n \"def mfa_cli(ctx: click.Context) -> None:\\n from montreal_forced_aligner.command_line.utils import check_server, start_server, stop_server\\n\\n config.load_configuration()\\n auto_server = False\\n run_check = True\\n if ctx.invoked_subcommand == \\\"anchor\\\":\\n config.CLEAN = False\\n config.USE_POSTGRES = True\\n config.CLEAN = False\\n config.USE_POSTGRES = True\\n if \\\"--help\\\" in sys.argv or ctx.invoked_subcommand in [\\n \\\"configure\\\",\\n \\\"version\\\",\\n \\\"history\\\",\\n \\\"server\\\",\\n \\\"align_one\\\",\\n ]:\\n auto_server = False\\n run_check = False\\n elif ctx.invoked_subcommand in [\\\"model\\\", \\\"models\\\"]:\\n if \\\"add_words\\\" in sys.argv or \\\"inspect\\\" in sys.argv:\\n config.CLEAN = True\\n config.USE_POSTGRES = False\\n else:\\n run_check = False\\n elif ctx.invoked_subcommand == \\\"g2p\\\":\\n if len(sys.argv) > 2 and sys.argv[2] == \\\"-\\\":\\n run_check = False\\n auto_server = False\\n else:\\n auto_server = config.AUTO_SERVER\\n if \\\"--no_use_postgres\\\" in sys.argv or not config.USE_POSTGRES:\\n run_check = False\\n auto_server = False\\n if auto_server:\\n start_server()\\n elif run_check:\\n check_server()\\n warnings.simplefilter(\\\"ignore\\\")\\n check_third_party()\\n if ctx.invoked_subcommand != \\\"anchor\\\":\\n hooks = ExitHooks()\\n hooks.hook()\\n atexit.register(hooks.history_save_handler)\\n if auto_server:\\n atexit.register(stop_server)\",\n \"def command(name):\\n def _decoration(fcn):\\n fcn.command = name\\n return fcn\\n return _decoration\",\n \"def load_alias(name):\\n mod = importlib.import_module(\\\"umdone.commands.\\\" + name)\\n main = getattr(mod, \\\"main\\\")\\n builtins.aliases[name] = main\\n builtins.aliases[name.replace(\\\"_\\\", \\\"-\\\")] = main\",\n \"def law(self, line):\\n line = line.strip()\\n if not line:\\n logger.error(r\\\"the command passed to %law must not be empty\\\")\\n return\\n\\n # build the full command\\n cmd = \\\"law \\\" + line\\n if line_cmd:\\n cmd = \\\"{} && {}\\\".format(line_cmd, cmd)\\n logger.debug(\\\"running law command '{}'\\\".format(cmd))\\n\\n # run it\\n return self._run_bash(cmd)\",\n \"def vim_normal_mode_exterm(cmd: str):\\n v = VimMode()\\n v.set_normal_mode_exterm()\\n actions.insert(cmd)\",\n \"def add_cmd(self, func, is_admin=False):\\n method = {}\\n vals = func.func_name.split('_')\\n if vals[0] == 'void':\\n method['template'] = void_template\\n elif vals[0] == 'string':\\n method['template'] = string_template\\n elif vals[0] == 'begin':\\n method['template'] = begin_template\\n else:\\n method['template'] = list_template\\n method['cmd'] = vals[1].upper()\\n if not vals[0] in self.templates:\\n msg = \\\"The first part of the function name must be %s\\\" % str(self.templates)\\n raise NamingError(msg)\\n if is_admin:\\n method['perm'] = 'M'\\n else:\\n method['perm'] = 'r'\\n args = inspect.getargspec(func)[0]\\n if 'args' in args:\\n method['has_arg'] = True\\n method['inst'] = \\\"Syntax %s <sp> args\\\" % method['cmd']\\n else:\\n method['has_arg'] = False\\n method['inst'] = \\\"Syntax %s\\\" % method['cmd']\\n made = self.arg_maker(args)\\n method['need'] = made[0]\\n method['arg'] = made[1]\\n method['func'] = func.__name__\\n method['mod'] = func.__module__\\n self.methods += [method]\",\n \"def lsmagic(self, parameter_s=''):\\n return MagicsDisplay(self.shell.magics_manager, ignore=[])\",\n \"def at_cmdset_creation(self):\\n self.add(default_cmds.CmdLook())\\n self.add(default_cmds.CmdSay())\",\n \"def _from_command_line():\\n # Manim can be called from the command line in three different\\n # ways. The first two involve using the manim or manimcm commands\\n prog = os.path.split(sys.argv[0])[-1]\\n from_cli_command = prog in [\\\"manim\\\", \\\"manimcm\\\"]\\n\\n # The third way involves using `python -m manim ...`. In this\\n # case, the CLI arguments passed to manim do not include 'manim',\\n # 'manimcm', or even 'python'. However, the -m flag will always\\n # be the first argument.\\n from_python_m = sys.argv[0] == \\\"-m\\\"\\n\\n return from_cli_command or from_python_m\",\n \"def test_macro(self):\\n env = create_env()\\n pkg = create_manifest(\\\"mock\\\")\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test)\\n cmd2()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([], result)\\n\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test)\\n if()\\n cmd()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([\\\"INDENTATION\\\"], result)\\n\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test2)\\n cmd()\\n endmacro()\\n macro(test)\\n if()\\n cmd()\\n test2()\\n cmd()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\\n self.assertEqual([], result)\\n result = mock_lint(env, pkg,\\n \\\"\\\"\\\"\\n macro(test4)\\n cmd()\\n if()\\n cmd()\\n endif()\\n endmacro()\\n macro(test3)\\n test4()\\n endmacro()\\n macro(test2)\\n test3()\\n if()\\n if()\\n if()\\n cmd()\\n test3()\\n endif()\\n endif()\\n endif()\\n endmacro()\\n macro(test)\\n test2()\\n if()\\n cmd()\\n test2()\\n else()\\n foreach(a b c d e)\\n test2()\\n endforeach()\\n endif()\\n endmacro()\\n cmd1()\\n test()\\n cmd3()\\n \\\"\\\"\\\", checks=None, indentation=True)\",\n \"def define_command(self, name, command):\\n code = (\\\"function %s {\\\"\\n \\\" %s \\\\\\\"$@\\\\\\\"\\\\n\\\"\\n \\\"}\\\") % (name, command)\\n self._printer(code)\",\n \"def get_ymal_load(yamlfile):\\n with open(yamlfile, 'r', encoding='utf-8') as fr:\\n filedata = fr.read()\\n yamldata = yaml.full_load(filedata)\\n return yamldata\",\n \"def __apf_cmd(cmd):\\n apf_cmd = \\\"{} {}\\\".format(salt.utils.path.which(\\\"apf\\\"), cmd)\\n out = __salt__[\\\"cmd.run_all\\\"](apf_cmd)\\n\\n if out[\\\"retcode\\\"] != 0:\\n if not out[\\\"stderr\\\"]:\\n msg = out[\\\"stdout\\\"]\\n else:\\n msg = out[\\\"stderr\\\"]\\n raise CommandExecutionError(\\\"apf failed: {}\\\".format(msg))\\n return out[\\\"stdout\\\"]\",\n \"def run_man(self, expanded, unexpanded) : \\n\\t\\tmethodslist = map(lambda n: n[4:], filter(lambda f: f[:4] == 'run_', self.__class__.__dict__.keys()))\\n\\t\\tif not unexpanded :\\n\\t\\t\\tunexpanded = methodslist\\n\\t\\tunexpanded.sort()\\n\\n\\t\\tresults = []\\n\\t\\tfor method in unexpanded :\\n\\t\\t\\tif results :\\n\\t\\t\\t\\t# more than one command to display help for\\n\\t\\t\\t\\t# so we separate them in the plain text output\\n\\t\\t\\t\\tself.printf(\\\"\\\\n--------\\\\n\\\\n\\\")\\n\\t\\t\\tif not hasattr(self, 'run_' + method) :\\n\\t\\t\\t\\thelp = helphtml = \\\"Invalid command\\\"\\n\\t\\t\\telse :\\n\\t\\t\\t\\thelp = getattr(self, 'run_' + method).__doc__\\n\\t\\t\\t\\tif not help :\\n\\t\\t\\t\\t\\thelp = helphtml = \\\"Undocumented command\\\"\\n\\t\\t\\t\\telse :\\n\\t\\t\\t\\t\\thelplines = map(string.strip, string.split(help, '\\\\n'))\\n\\t\\t\\t\\t\\thelp = string.join(helplines, '\\\\n')\\n\\t\\t\\t\\t\\thelphtml = string.join(helplines, '<br />')\\n\\t\\t\\tcommand = '<a href=\\\"%s?zshellscript=man%%20%s&zshellscript=%s&zshelldontrun=1\\\">%s</a>' % (self.__context.REQUEST.URL0, method, method, method)\\n\\t\\t\\tresults.append({\\\"Command\\\": command, \\\"Help\\\": helphtml})\\n\\t\\t\\tself.printf(\\\"%s: %s\\\\n\\\" % (method, help))\\n\\t\\tself.tableDisplay(\\\"man\\\", [\\\"Command\\\", \\\"Help\\\"], results)\",\n \"def run_lammps(lammps_executable, input_file, output_file):\\n # run lammps\\n lammps_command = f\\\"{lammps_executable} -in {input_file} \\\"\\n print(\\\"run command:\\\", lammps_command)\\n with open(\\\"tmp2False.out\\\", \\\"w+\\\") as fout:\\n subprocess.call(lammps_command.split(), stdout=fout)\",\n \"def main(raw_args):\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--module-link')\\n parser.add_argument('module_path', type=os.path.realpath)\\n args = parser.parse_args(raw_args)\\n\\n return md_module(\\n load_module_from_path(args.module_path), module_link=args.module_link)\",\n \"def cmd_mdtm(args):\",\n \"def launch_builtin_module(cmd, args):\\n\\n launch_path = \\\"%s/core/cmds/%s.py\\\" % (utils.get_pydtf_dir(), cmd)\\n\\n return __launch_python_module(launch_path, cmd, args)\",\n \"def manage(ctx, user_cmd):\\n ScalingoInterface(ctx.obj).manage_py(user_cmd)\",\n \"def _magic_docs(self, brief=False, rest=False):\\n mman = self.shell.magics_manager\\n docs = mman.lsmagic_docs(brief, missing='No documentation')\\n\\n if rest:\\n format_string = '**%s%s**::\\\\n\\\\n%s\\\\n\\\\n'\\n else:\\n format_string = '%s%s:\\\\n%s\\\\n'\\n\\n return ''.join(\\n [format_string % (magic_escapes['line'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['line'].items())]\\n +\\n [format_string % (magic_escapes['cell'], fname,\\n indent(dedent(fndoc)))\\n for fname, fndoc in sorted(docs['cell'].items())]\\n )\",\n \"def lammps(step, atomnum, boxbounds, addson = ''):\\r\\n\\r\\n line = 'ITEM: TIMESTEP\\\\n'\\r\\n line += str(step) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: NUMBER OF ATOMS\\\\n'\\r\\n line += str(atomnum) + '\\\\n'\\r\\n\\r\\n line += 'ITEM: BOX BOUNDS pp pp pp\\\\n'\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[0, 0], boxbounds[0, 1])\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[1, 0], boxbounds[1, 1])\\r\\n if boxbounds.shape[0] == 3:\\r\\n line += '%.6f %.6f\\\\n' %(boxbounds[2, 0], boxbounds[2, 1])\\r\\n else:\\r\\n line += '%.6f %.6f\\\\n' %(-0.5, 0.5)\\r\\n\\r\\n line += 'ITEM: ATOMS id type x y z %s\\\\n' %addson\\r\\n\\r\\n return line\",\n \"def stringSmuMod(self, arg):\\n\\t\\targ[0] = \\\"'\\\" + arg[0] + \\\"'\\\"\\n\\t\\targ[2] = \\\"'\\\" + arg[2] + \\\"'\\\"\\n\\t\\treturn arg\",\n \"def set_action_cmd(self, action):\\n if self.args.snapcheck is True:\\n action = \\\"snapcheck\\\"\\n if self.args.check is True:\\n action = \\\"check\\\"\\n if self.args.snap is True:\\n action = \\\"snap\\\"\\n if self.args.diff is True:\\n action = \\\"diff\\\"\\n return action\",\n \"async def manga(self, ctx: commands.Context) -> None:\\n if ctx.invoked_subcommand is None:\\n if ctx.subcommand_passed is None:\\n # There is no subcommand: inform the user about the manga reader.\\n summary = \\\"\\\"\\\"Hi! Welcome to Bakerbot's manga reader.\\n This cog houses commands for searching and reading manga.\\n See `$help mangadex` for a full list of available subcommands.\\\"\\\"\\\"\\n\\n embed = utilities.Embeds.standard()\\n embed.set_footer(text=\\\"Powered by the Mangadex API.\\\", icon_url=utilities.Icons.info)\\n embed.description = summary\\n await ctx.reply(embed=embed)\\n else:\\n # The subcommand was not valid: throw a fit.\\n command = f\\\"${ctx.command.name} {ctx.subcommand_passed}\\\"\\n summary = f\\\"`{command}` is not a valid command.\\\"\\n footer = \\\"Try $help mangadex for a full list of available subcommands.\\\"\\n embed = utilities.Embeds.status(False, summary)\\n embed.set_footer(text=footer, icon_url=utilities.Icons.cross)\\n await ctx.reply(embed=embed)\",\n \"def cmd(self, cmd):\\n return cmd\",\n \"def magic_ld(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep /$')\",\n \"def ipmagic(arg_s):\\n\\n args = arg_s.split(' ',1)\\n magic_name = args[0]\\n if magic_name.startswith(__IPYTHON__.ESC_MAGIC):\\n magic_name = magic_name[1:]\\n try:\\n magic_args = args[1]\\n except IndexError:\\n magic_args = ''\\n fn = getattr(__IPYTHON__,'magic_'+magic_name,None)\\n if fn is None:\\n error(\\\"Magic function `%s` not found.\\\" % magic_name)\\n else:\\n magic_args = __IPYTHON__.var_expand(magic_args)\\n return fn(magic_args)\",\n \"def add_cmd(self, cmd, name=\\\"\\\"):\\n if cmd:\\n self.cmds.add((cmd, name))\",\n \"def cmd_creator():\\n return OpenMayaMPx.asMPxPtr(AzureBatchSetup())\",\n \"def sub_command(self):\\n self.write(\\\"@SP\\\\nAM=M-1\\\\nD=M\\\\nA=A-1\\\\nM=M-D\\\\n\\\")\",\n \"def lemma(self) -> str:\",\n \"def podman(self, command: Command, **kwargs: Any) -> tmt.utils.CommandOutput:\\n return self.run(Command('podman') + command, **kwargs)\",\n \"def _mafft(exe, seq, outfile):\\n \\n args = [exe, '--quiet', seq]\\n try:\\n with open(outfile, 'w') as stdout:\\n process = Popen(args, stdout=stdout, stderr=PIPE,\\n universal_newlines=True)\\n code = process.wait()\\n except OSError:\\n msg = 'Failed to write alignment to outfile {}'.format(outfile)\\n error('Aligning sequence: {} via MUSCLE failed due to:\\\\n\\\\tIOError, '\\n 'failed to write alignment to outfile: {}.'.format(seq, outfile))\\n sys.exit(1)\\n if code:\\n if os.path.isfile(outfile):\\n os.remove(outfile)\\n msg = indent(process.stderr.read(), prefix='\\\\t')\\n process.stderr.close()\\n error('Aligning sequence: {} via MAFFT failed due to:\\\\n{}.'.format(seq,\\n msg))\\n sys.exit(1)\\n \\n return outfile\",\n \"def magic_r(self, parameter_s=''):\\n\\n start = parameter_s.strip()\\n # Identify magic commands even if automagic is on (which means\\n # the in-memory version is different from that typed by the user).\\n if self.shell.rc.automagic:\\n start_magic = '@'+start\\n else:\\n start_magic = start\\n # Look through the input history in reverse\\n for n in range(len(self.shell.input_hist)-2,0,-1):\\n input = self.shell.input_hist[n]\\n if input.startswith('#@'):\\n input = input[1:]\\n if input != '@r\\\\n' and \\\\\\n (input.startswith(start) or input.startswith(start_magic)):\\n #print 'match',`input` # dbg\\n if input.startswith('@'):\\n input = magic2python(input)\\n #print 'modified',`input` # dbg\\n print 'Executing:',input,\\n exec input in self.shell.user_ns\\n return\\n print 'No previous input matching `%s` found.' % start\",\n \"def command_(self, name):\\n def decorator(func):\\n func.__name__ = name\\n return self.command(func)\\n return decorator\",\n \"def run(md_file, interact):\\n lines = open(md_file, 'r').readlines()\\n blocks = extract_blocks(lines)\\n run_py(blocks, interact=interact)\",\n \"def magic_lf(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^-')\",\n \"def help_load(self):\\n help_str = \\\"\\\"\\\"Runs commands in script at file or URL.\\n\\n Usage: load [file_path]\\n\\n optional argument:\\n file_path - a file path or URL pointing to a script (default: value stored in `default_file_name` parameter)\\n\\nScript should contain one command per line, just like command would be typed in console.\\\"\\\"\\\"\\n self.stdout.write(\\\"{}\\\\n\\\".format(help_str))\",\n \"def ap(self) -> str:\\n return self.raw(\\\"ap\\\", \\\"\\\")\",\n \"def usage():\\n print \\\"\\\"\\\"\\nUsages:\\n ./lmf-merger.py -m file1 file2 outfile\\n ./lmf-merger.py -s file1 ...\\n example: ./lmf-merger.py data/lmf/ac_eko_dlouhe_50_xxx_lmf.xml \\\\\\n data/lmf/ac_frs_dlouhe_50_xxx_lmf.xml ac_eko-frs_dlouhe_50_xxx_lmf.xml\\n \\\"\\\"\\\"\",\n \"def __init__(self,cmds):\\n\\n # Since the list may include multi-line entries, first make sure that\\n # they've been all broken up before passing it to magic2python\\n cmdlist = map(magic2python,''.join(cmds).split('\\\\n'))\\n self.value = '\\\\n'.join(cmdlist)\",\n \"def lemmatize_verbs(self):\\n lemmas = []\\n # lemmas = \\\"\\\"\\n for word in self.words:\\n lemma = wn.lemmatize(word, pos='v')\\n lemmas.append(lemma)\\n # lemmas += f\\\"{lemma} \\\"\\n self.words = lemmas\\n return self\",\n \"def menu_help(cls, **attr):\\n menu_help = MM(\\\"Help\\\", c=\\\"default\\\", f=\\\"help\\\", **attr)(\\n MM(\\\"Contact us\\\", f=\\\"contact\\\"),\\n MM(\\\"About\\\", f=\\\"about\\\"),\\n MM(current.T(\\\"Ask MSW\\\"), c=\\\"org\\\", f=\\\"ask_msw\\\"),\\n MM(\\\"spiegel.de\\\", c=\\\"org\\\", f=\\\"spiegel\\\"),\\n )\\n return menu_help\",\n \"def manage_py(self, management_command_name, **options):\\n cmd = f\\\"python manage.py {management_command_name}\\\"\\n for name, val in options.items():\\n cmd += f\\\" --{name} {val}\\\"\\n self.run(cmd)\",\n \"def add_command(self, name, fct):\\r\\n self.cmds[name] = fct\",\n \"def use_mfa_secret_from_vault(\\n self, vault_name: str, vault_key: str, mode: OTPMode = OTPMode.TIME\\n ):\\n secrets = Vault().get_secret(vault_name)\\n if mode == OTPMode.TIME:\\n self.set_time_based_otp(secrets[vault_key])\\n elif mode == OTPMode.COUNTER:\\n self.set_counter_based_otp(secrets[vault_key])\",\n \"def _build_simple_command(self, cmd):\\n return cmd+SBE37_NEWLINE\",\n \"def help_util():\\r\\n for cmd, f in COMMANDS.items():\\r\\n print(\\\"POM \\\" + cmd + \\\":\\\")\\r\\n print(f.__doc__.lstrip(\\\"\\\\n\\\"))\",\n \"def mafft(inputseqfile, outputmsafile):\\n \\n command_msa = 'mafft --retree 2 --reorder ' + inputseqfile + ' > ' + outputmsafile\\n os.system(command_msa)\\n #os.system(\\\"mafft --retree 2 --reorder ks.fasta > ks.mafft.fasta\\\")\\n #subprocess.call(['mafft --retree 2 --reorder', 'ks.fasta', '>', 'ks.mafft.fasta']) not currently working\",\n \"def do_ls(self, line):\\n print(self.name, 'do---')\",\n \"def fusion_generate_mmmc_script(x: hammer_vlsi.HammerTool) -> str:\\n mmmc_output = [] # type: List[str]\\n\\n def append_mmmc(cmd: str) -> None:\\n x.verbose_tcl_append(cmd, mmmc_output)\\n\\n # Create an Innovus constraint mode.\\n constraint_mode = \\\"my_constraint_mode\\\"\\n sdc_files = [] # type: List[str]\\n\\n # Generate constraints\\n clock_constraints_fragment = os.path.join(x.run_dir, \\\"clock_constraints_fragment.sdc\\\")\\n with open(clock_constraints_fragment, \\\"w\\\") as f:\\n f.write(x.sdc_clock_constraints)\\n sdc_files.append(clock_constraints_fragment)\\n\\n # Generate port constraints.\\n pin_constraints_fragment = os.path.join(x.run_dir, \\\"pin_constraints_fragment.sdc\\\")\\n with open(pin_constraints_fragment, \\\"w\\\") as f:\\n f.write(x.sdc_pin_constraints)\\n sdc_files.append(pin_constraints_fragment)\\n\\n # Add the post-synthesis SDC, if present.\\n post_synth_sdc = x.post_synth_sdc\\n if post_synth_sdc is not None:\\n sdc_files.append(post_synth_sdc)\\n\\n # TODO: add floorplanning SDC\\n if len(sdc_files) > 0:\\n sdc_files_arg = \\\"-sdc_files [list {sdc_files}]\\\".format(\\n sdc_files=\\\" \\\".join(sdc_files)\\n )\\n else:\\n blank_sdc = os.path.join(x.run_dir, \\\"blank.sdc\\\")\\n x.run_executable([\\\"touch\\\", blank_sdc])\\n sdc_files_arg = \\\"-sdc_files {{ {} }}\\\".format(blank_sdc)\\n append_mmmc(\\\"create_constraint_mode -name {name} {sdc_files_arg}\\\".format(\\n name=constraint_mode,\\n sdc_files_arg=sdc_files_arg\\n ))\\n\\n corners = x.get_mmmc_corners() # type: List[MMMCCorner]\\n # In parallel, create the delay corners\\n if corners:\\n setup_corner = corners[0] # type: MMMCCorner\\n hold_corner = corners[0] # type: MMMCCorner\\n pwr_corner = corners[0] # type: MMMCCorner\\n # TODO(colins): handle more than one corner and do something with extra corners\\n for corner in corners:\\n if corner.type is MMMCCornerType.Setup:\\n setup_corner = corner\\n if corner.type is MMMCCornerType.Hold:\\n hold_corner = corner\\n if corner.type is MMMCCornerType.Extra:\\n pwr_corner = corner\\n\\n # First, create Innovus library sets\\n append_mmmc(\\\"create_library_set -name {name} -timing [list {list}]\\\".format(\\n name=\\\"{n}.setup_set\\\".format(n=setup_corner.name),\\n list=x.get_timing_libs(setup_corner)\\n ))\\n append_mmmc(\\\"create_library_set -name {name} -timing [list {list}]\\\".format(\\n name=\\\"{n}.hold_set\\\".format(n=hold_corner.name),\\n list=x.get_timing_libs(hold_corner)\\n ))\\n append_mmmc(\\\"create_library_set -name {name} -timing [list {list}]\\\".format(\\n name=\\\"{n}.pwr_set\\\".format(n=pwr_corner.name),\\n list=x.get_timing_libs(pwr_corner)\\n ))\\n # Skip opconds for now\\n # Next, create Innovus timing conditions\\n append_mmmc(\\\"create_timing_condition -name {name} -library_sets [list {list}]\\\".format(\\n name=\\\"{n}.setup_cond\\\".format(n=setup_corner.name),\\n list=\\\"{n}.setup_set\\\".format(n=setup_corner.name)\\n ))\\n append_mmmc(\\\"create_timing_condition -name {name} -library_sets [list {list}]\\\".format(\\n name=\\\"{n}.hold_cond\\\".format(n=hold_corner.name),\\n list=\\\"{n}.hold_set\\\".format(n=hold_corner.name)\\n ))\\n append_mmmc(\\\"create_timing_condition -name {name} -library_sets [list {list}]\\\".format(\\n name=\\\"{n}.pwr_cond\\\".format(n=pwr_corner.name),\\n list=\\\"{n}.pwr_set\\\".format(n=pwr_corner.name)\\n ))\\n # Next, create Innovus rc corners from qrc tech files\\n append_mmmc(\\\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\\\".format(\\n name=\\\"{n}.setup_rc\\\".format(n=setup_corner.name),\\n tempInCelsius=str(setup_corner.temp.value),\\n qrc=\\\"-qrc_tech {}\\\".format(x.get_mmmc_qrc(setup_corner)) if x.get_mmmc_qrc(setup_corner) != '' else ''\\n ))\\n append_mmmc(\\\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\\\".format(\\n name=\\\"{n}.hold_rc\\\".format(n=hold_corner.name),\\n tempInCelsius=str(hold_corner.temp.value),\\n qrc=\\\"-qrc_tech {}\\\".format(x.get_mmmc_qrc(hold_corner)) if x.get_mmmc_qrc(hold_corner) != '' else ''\\n ))\\n append_mmmc(\\\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\\\".format(\\n name=\\\"{n}.pwr_rc\\\".format(n=pwr_corner.name),\\n tempInCelsius=str(pwr_corner.temp.value),\\n qrc=\\\"-qrc_tech {}\\\".format(x.get_mmmc_qrc(pwr_corner)) if x.get_mmmc_qrc(pwr_corner) != '' else ''\\n ))\\n # Next, create an Innovus delay corner.\\n append_mmmc(\\n \\\"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\\\".format(\\n name=\\\"{n}.setup\\\".format(n=setup_corner.name)\\n ))\\n append_mmmc(\\n \\\"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\\\".format(\\n name=\\\"{n}.hold\\\".format(n=hold_corner.name)\\n ))\\n append_mmmc(\\n \\\"create_delay_corner -name {name}_delay -timing_condition {name}_cond -rc_corner {name}_rc\\\".format(\\n name=\\\"{n}.pwr\\\".format(n=pwr_corner.name)\\n ))\\n # Next, create the analysis views\\n append_mmmc(\\\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\\\".format(\\n name=\\\"{n}.setup\\\".format(n=setup_corner.name), constraint=constraint_mode))\\n append_mmmc(\\\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\\\".format(\\n name=\\\"{n}.hold\\\".format(n=hold_corner.name), constraint=constraint_mode))\\n append_mmmc(\\\"create_analysis_view -name {name}_view -delay_corner {name}_delay -constraint_mode {constraint}\\\".format(\\n name=\\\"{n}.pwr\\\".format(n=pwr_corner.name), constraint=constraint_mode))\\n # Finally, apply the analysis view.\\n append_mmmc(\\\"set_analysis_view -setup {{ {setup_view} }} -hold {{ {hold_view} }} -leakage {{ {pwr_view} }} -dynamic {{ {pwr_view} }}\\\".format(\\n setup_view=\\\"{n}.setup_view\\\".format(n=setup_corner.name),\\n hold_view=\\\"{n}.hold_view\\\".format(n=hold_corner.name),\\n pwr_view=\\\"{n}.pwr_view\\\".format(n=pwr_corner.name)\\n ))\\n else:\\n # First, create an Innovus library set.\\n library_set_name = \\\"my_lib_set\\\"\\n append_mmmc(\\\"create_library_set -name {name} -timing [list {list}]\\\".format(\\n name=library_set_name,\\n list=x.get_timing_libs()\\n ))\\n # Next, create an Innovus timing condition.\\n timing_condition_name = \\\"my_timing_condition\\\"\\n append_mmmc(\\\"create_timing_condition -name {name} -library_sets [list {list}]\\\".format(\\n name=timing_condition_name,\\n list=library_set_name\\n ))\\n # extra junk: -opcond ...\\n rc_corner_name = \\\"rc_cond\\\"\\n append_mmmc(\\\"create_rc_corner -name {name} -temperature {tempInCelsius} {qrc}\\\".format(\\n name=rc_corner_name,\\n tempInCelsius=120, # TODO: this should come from tech config\\n qrc=\\\"-qrc_tech {}\\\".format(x.get_qrc_tech()) if x.get_qrc_tech() != '' else ''\\n ))\\n # Next, create an Innovus delay corner.\\n delay_corner_name = \\\"my_delay_corner\\\"\\n append_mmmc(\\n \\\"create_delay_corner -name {name} -timing_condition {timing_cond} -rc_corner {rc}\\\".format(\\n name=delay_corner_name,\\n timing_cond=timing_condition_name,\\n rc=rc_corner_name\\n ))\\n # extra junk: -rc_corner my_rc_corner_maybe_worst\\n # Next, create an Innovus analysis view.\\n analysis_view_name = \\\"my_view\\\"\\n append_mmmc(\\\"create_analysis_view -name {name} -delay_corner {corner} -constraint_mode {constraint}\\\".format(\\n name=analysis_view_name, corner=delay_corner_name, constraint=constraint_mode))\\n # Finally, apply the analysis view.\\n # TODO: introduce different views of setup/hold and true multi-corner\\n append_mmmc(\\\"set_analysis_view -setup {{ {setup_view} }} -hold {{ {hold_view} }}\\\".format(\\n setup_view=analysis_view_name,\\n hold_view=analysis_view_name\\n ))\\n\\n return \\\"\\\\n\\\".join(mmmc_output)\",\n \"def list_param(command):\\n namespace = app.main(command)\\n assert namespace.command == 'lp' or namespace.command == \\\"listparam\\\"\",\n \"def run_lap():\\n pass\",\n \"def libmagic(self):\\n return self.tag(\\\"libmagic\\\")\",\n \"def label(cmd):\\r\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\r\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\r\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\r\\n return cmd\",\n \"def modulecmds():\\n\\n class Commands:\\n @staticmethod\\n def setenv(key, val=None):\\n val = val or key\\n return \\\"setenv({0!r}, {1!r})\\\\n\\\".format(key, val)\\n\\n @staticmethod\\n def unsetenv(key):\\n return \\\"unsetenv({0!r})\\\\n\\\".format(key)\\n\\n @staticmethod\\n def load(x):\\n return \\\"load({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def load_first(*x):\\n x = \\\",\\\".join(\\\"{0!r}\\\".format(_) for _ in x)\\n return \\\"load_first({0})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def unload(x):\\n return \\\"unload({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def prepend_path(key, val=None, sep=os.pathsep):\\n val = val or key\\n return \\\"prepend_path({0!r},{1!r},sep={2!r})\\\\n\\\".format(key, val, sep)\\n\\n @staticmethod\\n def append_path(key, val=None, sep=os.pathsep):\\n val = val or key\\n return \\\"append_path({0!r},{1!r},sep={2!r})\\\\n\\\".format(key, val, sep)\\n\\n @staticmethod\\n def remove_path(key, val=None, sep=os.pathsep):\\n val = val or key\\n return \\\"remove_path({0!r},{1!r},sep={2!r})\\\\n\\\".format(key, val, sep)\\n\\n @staticmethod\\n def set_alias(key, val):\\n return \\\"set_alias({0!r},{1!r})\\\\n\\\".format(key, val)\\n\\n @staticmethod\\n def unset_alias(key):\\n return \\\"unset_alias({0!r})\\\\n\\\".format(key)\\n\\n @staticmethod\\n def set_shell_function(key, val):\\n return \\\"set_shell_function({0!r},{1!r})\\\\n\\\".format(key, val)\\n\\n @staticmethod\\n def unset_shell_function(key):\\n return \\\"unset_shell_function({0!r})\\\\n\\\".format(key)\\n\\n @staticmethod\\n def use(path):\\n return \\\"use({0!r})\\\\n\\\".format(path)\\n\\n @staticmethod\\n def unuse(path):\\n return \\\"unuse({0!r})\\\\n\\\".format(path)\\n\\n @staticmethod\\n def swap(a, b):\\n return \\\"swap({0!r}, {1!r})\\\\n\\\".format(a, b)\\n\\n @staticmethod\\n def family(x):\\n return \\\"family({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def conflict(x):\\n return \\\"conflict({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def prereq(x):\\n return \\\"prereq({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def prereq_any(*x):\\n x = \\\",\\\".join(\\\"{0!r}\\\".format(_) for _ in x)\\n return \\\"prereq_any({0})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def source(f):\\n return \\\"source({0!r})\\\\n\\\".format(f)\\n\\n @staticmethod\\n def help(x):\\n return \\\"help({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def whatis(x):\\n return \\\"whatis({0!r})\\\\n\\\".format(x)\\n\\n @staticmethod\\n def isloaded(x):\\n return \\\"is_loaded({0!r})\\\\n\\\".format(x)\\n\\n return Commands()\",\n \"def _opm(command, runas=None):\\n cmdline = [\\\"opm\\\"] + command\\n ret = __salt__[\\\"cmd.run_all\\\"](cmdline, runas=runas, python_shell=False)\\n\\n if ret[\\\"retcode\\\"] == 0:\\n return ret[\\\"stdout\\\"]\\n\\n raise CommandExecutionError(ret[\\\"stderr\\\"])\",\n \"def edit_ruleset(command):\\n namespace = app.main(command)\\n assert namespace.command == 'er' or namespace.command == \\\"editruleset\\\"\\n assert namespace.name == \\\"test\\\"\\n assert namespace.action in ['a','d']\",\n \"def magic_automagic(self, parameter_s = ''):\\n \\n self.rc.automagic = 1 - self.rc.automagic\\n print '\\\\n' + Magic.auto_status[self.rc.automagic]\",\n \"def test_matmul_mm(self):\\n self.check_dot_mm(matmul_usecase, None, \\\"'@'\\\")\",\n \"def lt_command(self):\\n self.write(\\n \\\"@SP\\\\nA=M-1\\\\nD=M\\\\n@NEG1\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JLT\\\\n@POS1\\\" + str(\\n self.__label_num) +\\n \\\"\\\\nD;JGE\\\\n(NEG1\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nA=A-1\\\\nD=M\\\\n@POS2\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JGT\\\\n@CONT\\\"\\n + str(self.__label_num) + \\\"\\\\n0;JMP\\\\n(POS1\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nA=A-1\\\\nD=M\\\\n@NEG2\\\" +\\n str(self.__label_num) + \\\"\\\\nD;JLT\\\\n@CONT\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(POS2\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\"\\n \\\"\\\\nA=M-1\\\\nA=A-1\\\\nM=0\\\\n@SP\\\\nM=M-1\\\\n@ENDLABEL\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(NEG2\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\" +\\n \\\"\\\\nA=M-1\\\\nA=A-1\\\\nM=-1\\\\n@SP\\\\nM=M-1\\\\n@ENDLABEL\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(CONT\\\" + str(\\n self.__label_num) + \\\")\\\\n\\\"\\n \\\"@SP\\\\nM=M-1\\\\nA=M\\\\nD=M\\\\n@SP\\\\nA=M-1\\\\nD=M-D\\\\n@TRUE\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JGE\\\\n@SP\\\\nA=M-1\\\\nM=-1\\\\n@ENDLABEL\\\" +\\n str(self.__label_num) + \\\"\\\\n0;JMP\\\\n(TRUE\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nM=0\\\\n(ENDLABEL\\\" +\\n str(self.__label_num) + \\\")\\\\n\\\")\",\n \"def _handleAnchor(self):\\n if self._lastCommand == \\\"M\\\":\\n self._commands.pop(-1)\",\n \"def extendMarkdown(self, md, md_globals):\\r\\n md.inlinePatterns['autolink'] = UrlizePattern(URLIZE_RE, md)\",\n \"def lammpsdata(atomnum, atomtypes, boxbounds):\\r\\n\\r\\n line = '#LAMMPS data file\\\\n\\\\n'\\r\\n line += '%d atoms\\\\n' %(atomnum)\\r\\n line += '%d atom types\\\\n\\\\n' %(atomtypes)\\r\\n line += '%.6f %.6f xlo xhi\\\\n' %(boxbounds[0, 0], boxbounds[0, 1])\\r\\n line += '%.6f %.6f ylo yhi\\\\n' %(boxbounds[1, 0], boxbounds[1, 1])\\r\\n line += '%.6f %.6f zlo zhi\\\\n' %(boxbounds[2, 0], boxbounds[2, 1])\\r\\n line += '\\\\nAtoms #atomic\\\\n'\\r\\n\\r\\n return line\",\n \"def vim_normal_mode_exterm_key(cmd: str):\\n v = VimMode()\\n v.set_normal_mode_exterm()\\n actions.key(cmd)\",\n \"def define_command(self, name, command):\\n code = (\\\"function %s {\\\"\\n \\\" %s $args\\\\n\\\"\\n \\\" $status = $?\\\\n\\\"\\n \\\" If ($status -eq 0) {\\\\n\\\"\\n \\\" exit 1\\\\n\\\"\\n \\\" }\\\\n\\\"\\n \\\"}\\\") % (name, command)\\n self._printer(code)\",\n \"def register_command(app: MaraApp, command: click.Command, package: str):\\n if isinstance(command, click.MultiCommand):\\n app.cli.add_command(command)\\n else:\\n command.name = package + '.' + command.name\\n app.cli.add_command(command)\",\n \"def parseargs(p):\\n p.set_defaults(func=func)\\n p.description = \\\"Print machine architecture.\\\"\\n return p\",\n \"def set_linker_script(self, op):\\n self.__linker_script = [\\\"-T\\\", op]\",\n \"def role_command():\",\n \"def label(cmd):\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\n return cmd\",\n \"def form_m(orig: Symbol):\\n return _decor_base(orig, lambda _: 'm')\",\n \"def cmd(self, cmd):\\n\\n self._cmd = cmd\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6546807","0.5515294","0.52751005","0.52579564","0.5237155","0.51861405","0.512959","0.5102926","0.49472788","0.49453253","0.49353927","0.49225372","0.4891675","0.48703486","0.47610494","0.470173","0.46908697","0.4684091","0.46759415","0.4654112","0.46485576","0.4603076","0.46006072","0.45542857","0.455096","0.45361915","0.44818726","0.44448832","0.44351497","0.44261438","0.44117993","0.4403854","0.4403591","0.43906066","0.43881726","0.43858838","0.43836477","0.43793893","0.43761694","0.4335383","0.43237317","0.4323043","0.4318944","0.43130058","0.43128794","0.4310006","0.42963868","0.42945915","0.42803603","0.4277259","0.42503437","0.42500165","0.42353123","0.42351526","0.4227589","0.42271093","0.4226045","0.42259473","0.41946024","0.41894495","0.4173918","0.41655126","0.416416","0.41640645","0.4158123","0.41575405","0.4153801","0.41453683","0.41453212","0.4142994","0.41418722","0.41383436","0.41287053","0.41254866","0.41163674","0.4116024","0.41142663","0.41138142","0.41093928","0.41058645","0.41055483","0.41018417","0.4093851","0.40900835","0.40888077","0.4082256","0.40780997","0.4076486","0.40722966","0.40717837","0.40716243","0.4071223","0.4067686","0.4065196","0.4062471","0.40606266","0.40564853","0.40530455","0.40518788","0.4046241"],"string":"[\n \"0.6546807\",\n \"0.5515294\",\n \"0.52751005\",\n \"0.52579564\",\n \"0.5237155\",\n \"0.51861405\",\n \"0.512959\",\n \"0.5102926\",\n \"0.49472788\",\n \"0.49453253\",\n \"0.49353927\",\n \"0.49225372\",\n \"0.4891675\",\n \"0.48703486\",\n \"0.47610494\",\n \"0.470173\",\n \"0.46908697\",\n \"0.4684091\",\n \"0.46759415\",\n \"0.4654112\",\n \"0.46485576\",\n \"0.4603076\",\n \"0.46006072\",\n \"0.45542857\",\n \"0.455096\",\n \"0.45361915\",\n \"0.44818726\",\n \"0.44448832\",\n \"0.44351497\",\n \"0.44261438\",\n \"0.44117993\",\n \"0.4403854\",\n \"0.4403591\",\n \"0.43906066\",\n \"0.43881726\",\n \"0.43858838\",\n \"0.43836477\",\n \"0.43793893\",\n \"0.43761694\",\n \"0.4335383\",\n \"0.43237317\",\n \"0.4323043\",\n \"0.4318944\",\n \"0.43130058\",\n \"0.43128794\",\n \"0.4310006\",\n \"0.42963868\",\n \"0.42945915\",\n \"0.42803603\",\n \"0.4277259\",\n \"0.42503437\",\n \"0.42500165\",\n \"0.42353123\",\n \"0.42351526\",\n \"0.4227589\",\n \"0.42271093\",\n \"0.4226045\",\n \"0.42259473\",\n \"0.41946024\",\n \"0.41894495\",\n \"0.4173918\",\n \"0.41655126\",\n \"0.416416\",\n \"0.41640645\",\n \"0.4158123\",\n \"0.41575405\",\n \"0.4153801\",\n \"0.41453683\",\n \"0.41453212\",\n \"0.4142994\",\n \"0.41418722\",\n \"0.41383436\",\n \"0.41287053\",\n \"0.41254866\",\n \"0.41163674\",\n \"0.4116024\",\n \"0.41142663\",\n \"0.41138142\",\n \"0.41093928\",\n \"0.41058645\",\n \"0.41055483\",\n \"0.41018417\",\n \"0.4093851\",\n \"0.40900835\",\n \"0.40888077\",\n \"0.4082256\",\n \"0.40780997\",\n \"0.4076486\",\n \"0.40722966\",\n \"0.40717837\",\n \"0.40716243\",\n \"0.4071223\",\n \"0.4067686\",\n \"0.4065196\",\n \"0.4062471\",\n \"0.40606266\",\n \"0.40564853\",\n \"0.40530455\",\n \"0.40518788\",\n \"0.4046241\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6613872"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20185,"cells":{"query":{"kind":"string","value":"Defines the way to parse the magic command ``%%mlnet``."},"document":{"kind":"string","value":"def mlnet_parser():\n parser = MagicCommandParser(prog=\"mlnet\",\n description='Compiles and wrap a C# function into a Python function.\\n'\n 'Automatically adds ML.net dependencies.')\n parser.add_argument('name', type=str, help='function name')\n parser.add_argument('-i', '--idep', nargs='*', action='append',\n help='internal dependencies (like System, System.Linq)')\n parser.add_argument('-d', '--dep', nargs='*', action='append',\n help='dependencies (assembly name without extension)')\n parser.add_argument('-c', '--catch', action='store', default=False,\n help='catch exception')\n return parser"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mlnet(self, line, cell):\n line, cell = CsMagics._preprocess_line_cell_maml( # pylint: disable=W0212\n line, cell)\n\n parser = self.get_parser(CsMagics.CS_parser, \"CS\")\n args = self.get_args(line, parser)\n\n if args is not None:\n name = args.name\n dep = CsMagics._linearise_args(args.dep) # pylint: disable=W0212\n idep = CsMagics._linearise_args(args.idep) # pylint: disable=W0212\n\n if args.catch:\n try:\n f = mlnet(name, cell, idep, dep)\n except Exception as e: # pylint: disable=W0703\n print(str(e).replace('\\r', ''))\n return None\n else:\n f = mlnet(name, cell, idep, dep)\n if self.shell is not None:\n self.shell.user_ns[name] = f\n return f\n return None","def cmd_nlst(args):","def niw_mmml_mp(args):\n return niw_mmml(*args)","def magic2python(cmd):\n\n if cmd.startswith('#@') or cmd.startswith('@'):\n if cmd[0]=='#':\n cmd = cmd[1:]\n # we need to return the proper line end later\n if cmd[-1] == '\\n':\n endl = '\\n'\n else:\n endl = ''\n try:\n func,args = cmd[1:].split(' ',1)\n except:\n func,args = cmd[1:].rstrip(),''\n args = args.replace('\"','\\\\\"').replace(\"'\",\"\\\\'\").rstrip()\n return '__IP.magic_%s (\"%s\")%s' % (func,args,endl)\n else:\n return cmd","def parse_args():\n parser = argparse.ArgumentParser(description='MXNet Gluon Semantic Segmentation')\n # model and dataset\n parser.add_argument('--model', type=str, default='fcn',\n help='model name (default: fcn)')\n parser.add_argument('--model-zoo', type=str, default=None,\n help='evaluating on model zoo model')\n parser.add_argument('--pretrained', action=\"store_true\",\n help='whether to use pretrained params')\n parser.add_argument('--backbone', type=str, default='resnet50',\n help='backbone name (default: resnet50)')\n parser.add_argument('--dataset', type=str, default='pascal',\n help='dataset name (default: pascal)')\n parser.add_argument('--workers', type=int, default=16,\n metavar='N', help='dataloader threads')\n parser.add_argument('--base-size', type=int, default=520,\n help='base image size')\n parser.add_argument('--crop-size', type=int, default=480,\n help='crop image size')\n parser.add_argument('--train-split', type=str, default='train',\n help='dataset train split (default: train)')\n # training hyper params\n parser.add_argument('--aux', action='store_true', default=False,\n help='Auxiliary loss')\n parser.add_argument('--aux-weight', type=float, default=0.5,\n help='auxiliary loss weight')\n parser.add_argument('--epochs', type=int, default=50, metavar='N',\n help='number of epochs to train (default: 50)')\n parser.add_argument('--start_epoch', type=int, default=0,\n metavar='N', help='start epochs (default:0)')\n parser.add_argument('--batch-size', type=int, default=16,\n metavar='N', help='input batch size for \\\n training (default: 16)')\n parser.add_argument('--test-batch-size', type=int, default=16,\n metavar='N', help='input batch size for \\\n testing (default: 16)')\n parser.add_argument('--optimizer', type=str, default='sgd',\n help='optimizer (default: sgd)')\n parser.add_argument('--lr', type=float, default=1e-3, metavar='LR',\n help='learning rate (default: 1e-3)')\n parser.add_argument('--warmup-epochs', type=int, default=0,\n help='number of warmup epochs.')\n parser.add_argument('--momentum', type=float, default=0.9,\n metavar='M', help='momentum (default: 0.9)')\n parser.add_argument('--weight-decay', type=float, default=1e-4,\n metavar='M', help='w-decay (default: 1e-4)')\n parser.add_argument('--no-wd', action='store_true',\n help='whether to remove weight decay on bias, \\\n and beta/gamma for batchnorm layers.')\n parser.add_argument('--mode', type=str, default=None,\n help='whether to turn on model hybridization')\n # cuda and distribute\n parser.add_argument('--no-cuda', action='store_true', default=False,\n help='disables CUDA training')\n parser.add_argument('--ngpus', type=int,\n default=len(mx.test_utils.list_gpus()),\n help='number of GPUs (default: 4)')\n parser.add_argument('--kvstore', type=str, default='device',\n help='kvstore to use for trainer/module.')\n parser.add_argument('--dtype', type=str, default='float32',\n help='data type for training. default is float32')\n # checking point\n parser.add_argument('--resume', type=str, default=None,\n help='put the path to resuming file if needed')\n parser.add_argument('--checkname', type=str, default='default',\n help='set the checkpoint name')\n parser.add_argument('--save-dir', type=str, default=None,\n help='directory of saved models')\n parser.add_argument('--log-interval', type=int, default=20,\n help='Number of batches to wait before logging.')\n parser.add_argument('--logging-file', type=str, default='train.log',\n help='name of training log file')\n # evaluation only\n parser.add_argument('--eval', action='store_true', default=False,\n help='evaluation only')\n parser.add_argument('--no-val', action='store_true', default=False,\n help='skip validation during training')\n # synchronized Batch Normalization\n parser.add_argument('--syncbn', action='store_true', default=False,\n help='using Synchronized Cross-GPU BatchNorm')\n # the parser\n args = parser.parse_args()\n\n # handle contexts\n if args.no_cuda:\n print('Using CPU')\n args.kvstore = 'local'\n args.ctx = [mx.cpu(0)]\n else:\n print('Number of GPUs:', args.ngpus)\n assert args.ngpus > 0, 'No GPUs found, please enable --no-cuda for CPU mode.'\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\n\n if 'psp' in args.model or 'deeplab' in args.model:\n assert args.crop_size % 8 == 0, ('For PSPNet and DeepLabV3 model families, '\n 'we only support input crop size as multiples of 8.')\n\n # logging and checkpoint saving\n if args.save_dir is None:\n args.save_dir = \"runs/%s/%s/%s/\" % (args.dataset, args.model, args.backbone)\n makedirs(args.save_dir)\n\n # Synchronized BatchNorm\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\n else mx.gluon.nn.BatchNorm\n args.norm_kwargs = {'num_devices': args.ngpus} if args.syncbn else {}\n return args","def net_cmd(self):\n \n logging.debug(\"net_cmd called\")\n cmd = \"\"\n # FIXME should probably grab the PrefixLength from the network definition\n # calc my router\n \n # FIXME: Need to split this into separate files...\n # files will be a dictionary of {\"filename\":\"contents\"}\n files = {}\n \n cmd = \"rem cmd\\r\\n\"\n tmpl = \"\"\"netsh interface ip set address \"%(nic)s\" static %(v4_fixed_ip)s 255.255.255.0\\r\\n\"\"\"\n # FIXME: this should be read out of the configuration, probably\n nets = self.networks\n ips = self.ip_addresses \n my_router = \"\"\n for netname in nets:\n v4_fixed_ip = ips.get(netname)\n my_net = v4_fixed_ip.split(\".\")[:3]\n my_net.append(\"254\")\n my_router = \".\".join(my_net)\n nic = \"%s-%s\" % (self.footprint.footprint_name, netname)\n logging.debug(\"Creating %s for %s\" % (nic, nets))\n # net_id = self.networks.get(netname)\n cmd = cmd + tmpl % locals()\n \n cmd += \"\"\"route -p add 192.168.1.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n cmd += \"\"\"route -p add 192.168.2.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n cmd += \"\"\"route -p add 192.168.3.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n logging.debug(\"cmdfile:\\n\" + cmd)\n \n # print 50 * \"x\"\n # print cmd\n return cmd","def parse_args():\n parser = argparse.ArgumentParser(description='MXNet Gluon Segmentation')\n\n parser.add_argument('--model', type=str, default='fcn', help='model name (default: fcn)')\n parser.add_argument('--backbone', type=str, default='resnet50', help='backbone name (default: resnet50)')\n parser.add_argument('--dataset', type=str, default='pascalaug', help='dataset name (default: pascal)')\n parser.add_argument('--dataset-dir', type=str, default='../imgclsmob_data/voc', help='dataset path')\n parser.add_argument('--workers', type=int, default=16, metavar='N', help='dataloader threads')\n parser.add_argument('--base-size', type=int, default=520, help='base image size')\n parser.add_argument('--crop-size', type=int, default=480, help='crop image size')\n\n parser.add_argument('--batch-size', type=int, default=1, metavar='N', help='input batch size for testing')\n\n parser.add_argument('--ngpus', type=int, default=len(mx.test_utils.list_gpus()), help='number of GPUs (default: 4)')\n\n # checking point\n parser.add_argument('--resume', type=str, default=None, help='put the path to resuming file if needed')\n parser.add_argument('--checkname', type=str, default='default', help='set the checkpoint name')\n parser.add_argument('--model-zoo', type=str, default=None, help='evaluating on model zoo model')\n\n # the parser\n args = parser.parse_args()\n # handle contexts\n if args.ngpus == 0:\n args.ctx = [mx.cpu(0)]\n else:\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\n args.test_batch_size = args.ngpus if args.ngpus > 0 else 1\n print(args)\n return args","def test_shortopt(self):\n pp = ParlaiParser(False, False)\n pp.add_argument(\"-m\", \"--model\")\n pp.add_argument(\"-mtw\", \"--multitask-weights\")\n opt = pp.parse_args([\"-m\", \"memnn\"])\n print(opt)","def cmd_mt_irc(word, word_eol, userdata):\n\tif len(word) > 1:\n\t\tsubcmd = word[1]\n\t\tif subcmd in subcommands:\n\t\t\tsubcmd = subcommands[subcmd]\n\t\t\tsubcmd(word[1:], word_eol[1:])\n\t\telse:\n\t\t\tprint('[mt_irc] Unknown subcommand \"%s\". Try \"/mt_irc help\".')\n\telse:\n\t\tprint('Usage: /mt_irc SUBCOMMAND')\n\t\tprint('Try \"/mt_irc help\".')\n\treturn xchat.EAT_XCHAT","def _parse_network_list(self, *cmd):\n if self._fail_network_list:\n raise processutils.ProcessExecutionError(exit_code=1)\n else:\n return NETWORK_LIST, ''","def parse_args():\n parser = argparse.ArgumentParser(description='MXNet Gluon Segmentation')\n parser.add_argument('--host', type=str, default='xxx',\n help='xxx is a place holder')\n parser.add_argument('--model', type=str, default='ResFPN',\n help='model name: ResNetFPN, ResUNet')\n parser.add_argument('--fuse-mode', type=str, default='AsymBi',\n help='DirectAdd, Concat, SK, BiLocal, BiGlobal, AsymBi, '\n 'TopDownGlobal, TopDownLocal')\n parser.add_argument('--tiny', action='store_true', default=False,\n help='evaluation only')\n parser.add_argument('--blocks', type=int, default=3,\n help='block num in each stage')\n parser.add_argument('--channel-times', type=int, default=1,\n help='times of channel width')\n parser.add_argument('--dataset', type=str, default='DENTIST',\n help='dataset name: DENTIST, Iceberg, StopSign')\n parser.add_argument('--workers', type=int, default=48,\n metavar='N', help='dataloader threads')\n parser.add_argument('--base-size', type=int, default=512,\n help='base image size')\n parser.add_argument('--iou-thresh', type=float, default=0.5,\n help='iou-thresh')\n parser.add_argument('--crop-size', type=int, default=480,\n help='crop image size')\n parser.add_argument('--train-split', type=str, default='trainval',\n help='dataset train split (default: train)')\n parser.add_argument('--val-split', type=str, default='test',\n help='dataset val split (default: val)')\n # training hyper params\n parser.add_argument('--epochs', type=int, default=300, metavar='N',\n help='number of epochs to train (default: 110)')\n parser.add_argument('--start_epoch', type=int, default=0,\n metavar='N', help='start epochs (default:0)')\n parser.add_argument('--batch-size', type=int, default=8,\n metavar='N', help='input batch size for \\\n training (default: 16)')\n parser.add_argument('--test-batch-size', type=int, default=8,\n metavar='N', help='input batch size for \\\n testing (default: 32)')\n parser.add_argument('--optimizer', type=str, default='adagrad',\n help='sgd, adam, adagrad')\n parser.add_argument('--lr', type=float, default=0.05, metavar='LR',\n help='learning rate (default: 0.1)')\n parser.add_argument('--lr-decay', type=float, default=0.1,\n help='decay rate of learning rate. default is 0.1.')\n parser.add_argument('--gamma', type=int, default=2,\n help='gamma for Focal Soft IoU Loss')\n parser.add_argument('--momentum', type=float, default=0.9,\n metavar='M', help='momentum (default: 0.9)')\n parser.add_argument('--weight-decay', type=float, default=1e-4,\n metavar='M', help='w-decay (default: 1e-4)')\n parser.add_argument('--no-wd', action='store_true',\n help='whether to remove weight decay on bias, \\\n and beta/gamma for batchnorm layers.')\n parser.add_argument('--score-thresh', type=float, default=0.5,\n help='score-thresh')\n parser.add_argument('--warmup-epochs', type=int, default=0,\n help='number of warmup epochs.')\n # cuda and logging\n parser.add_argument('--no-cuda', action='store_true', default=\n False, help='disables CUDA training')\n parser.add_argument('--gpus', type=str, default='0',\n help='Training with GPUs, you can specify 1,3 for example.')\n parser.add_argument('--kvstore', type=str, default='device',\n help='kvstore to use for trainer/module.')\n parser.add_argument('--dtype', type=str, default='float32',\n help='data type for training. default is float32')\n parser.add_argument('--wd', type=float, default=0.0001,\n help='weight decay rate. default is 0.0001.')\n parser.add_argument('--log-interval', type=int, default=50,\n help='Number of batches to wait before logging.')\n # checking point\n parser.add_argument('--resume', type=str, default=None,\n help='put the path to resuming file if needed')\n parser.add_argument('--colab', action='store_true', default=\n False, help='whether using colab')\n parser.add_argument('--save-dir', type=str, default=None,\n help='directory of saved models')\n # evaluation only\n parser.add_argument('--eval', action='store_true', default= False,\n help='evaluation only')\n parser.add_argument('--no-val', action='store_true', default= False,\n help='skip validation during training')\n parser.add_argument('--metric', type=str, default='mAP',\n help='F1, IoU, mAP')\n parser.add_argument('--logging-file', type=str, default='train.log',\n help='name of training log file')\n parser.add_argument('--summary', action='store_true',\n help='print parameters')\n # synchronized Batch Normalization\n parser.add_argument('--syncbn', action='store_true', default= False,\n help='using Synchronized Cross-GPU BatchNorm')\n # the parser\n args = parser.parse_args()\n # handle contexts\n if args.no_cuda or (len(mx.test_utils.list_gpus()) == 0):\n print('Using CPU')\n args.kvstore = 'local'\n args.ctx = [mx.cpu(0)]\n else:\n args.ctx = [mx.gpu(int(i)) for i in args.gpus.split(',') if i.strip()]\n print('Number of GPUs:', len(args.ctx))\n\n # logging and checkpoint saving\n if args.save_dir is None:\n args.save_dir = \"runs/%s/%s/\" % (args.dataset, args.model)\n makedirs(args.save_dir)\n\n # Synchronized BatchNorm\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\n else mx.gluon.nn.BatchNorm\n args.norm_kwargs = {'num_devices': len(args.ctx)} if args.syncbn else {}\n print(args)\n return args","def _parse_ml(self, line):\n # Parse the line\n fields = line.split('\\\\')\n if self.lang == ENGLISH:\n # pylint: disable=C0301\n # English sample:\n # 14\\abandonment\\94\\C\\\\1\\N\\N\\N\\N\\Y\\abandon+ment\\2x\\SA\\N\\N\\N\\#\\N\\N\\SA\\((abandon)[V],(ment)[N|V.])[N]\\N\\N\\N\n # From the README:\n # The eml.cd file contains the following fields:\n # 1. IdNum\n # 2. Head\n # 3. Cob\n # 4. MorphStatus\n # 5. Lang\n # 6. MorphCnt\n # 7. NVAffComp\n # 8. Der\n # 9. Comp\n # 10. DerComp\n # 11. Def\n # 12. Imm\n # 13. ImmSubCat\n # 14. ImmSA\n # 15. ImmAllo\n # 16. ImmSubst\n # 17. ImmOpac\n # 18. TransDer\n # 19. ImmInfix\n # 20. ImmRevers\n # 21 FlatSA\n # 22. StrucLab\n # 23. StrucAllo\n # 24. StrucSubst\n # 25. StrucOpac\n lemma = fields[0]\n word = fields[1]\n derivation = fields[21]\n elif self.lang == DUTCH:\n # pylint: disable=C0301\n # Dutch sample:\n # 19\\aalbessengelei\\7\\C\\1\\Y\\Y\\Y\\aalbes+en+gelei\\NxN\\N\\N\\(((aal)[N],(bes)[N])[N],(en)[N|N.N],(gelei)[N])[N]\\N\\N\\N\n # The dml.cd file contains the following fields:\n # 1. IdNum\n # 2. Head\n # 3. Inl\n # 4. MorphStatus\n # 5. MorphCnt\n # 6. DerComp\n # 7. Comp\n # 8. Def\n # 9. Imm\n # 10. ImmSubCat\n # 11. ImmAllo\n # 12. ImmSubst\n # 13. StrucLab\n # 14. StruAcAllo\n # 15. StrucSubst\n # 16. Sepa\n lemma = fields[0]\n word = fields[1]\n derivation = fields[12]\n\n # Skip multi-word entries for roots\n roots = self._get_root(derivation) if \" \" not in word else None\n return (lemma, word, roots)","def maml_parser():\n parser = MagicCommandParser(prog=\"maml\",\n description='Runs a maml script.')\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\n help='hide output')\n return parser","def command(self,cmd):\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))","def _make_matlab_command(self):\n \n raise NotImplementedError","def brain(msg):\n\n def check_message(msg):\n \"\"\"\n Check wich neuron to use.\n :param msg:\n :return:\n \"\"\"\n words_of_message = msg.split()\n find = False\n for key in gc_words:\n if words_of_message in gc_words[key]['groups']:\n getattr(neuron.general_conversations, key)()\n find = True\n break\n for key in fc_words:\n if words_of_message in fc_words[key]['groups']:\n getattr(neuron.forecast, key)()\n find = True\n break\n for key in twitter_words:\n if words_of_message in twitter_words[key]['groups']:\n getattr(neuron.twitter, key)()\n find = True\n break\n for key in pipo_words:\n if words_of_message in pipo_words[key]['groups']:\n getattr(neuron.pipotron, key)()\n find = True\n break\n if not find:\n neuron.general_conversations.undefined()\n\n check_message(msg)","def main_net_args(parser, allowed_nets=['fc'], dfc_arch='100,100',\n dmlp_arch='100,100', show_net_act=True, dnet_act='relu',\n show_no_bias=False, show_dropout_rate=True,\n ddropout_rate=-1, show_specnorm=True, show_batchnorm=True,\n show_no_batchnorm=False, show_bn_no_running_stats=False,\n show_bn_distill_stats=False,\n show_bn_no_stats_checkpointing=False,\n prefix=None, pf_name=None):\n assert(prefix is None or pf_name is not None)\n\n # TODO Delete 'fc' from list.\n for nt in allowed_nets:\n assert(nt in ['fc', 'mlp', 'resnet', 'zenke', 'bio_conv_net'])\n\n assert(not show_batchnorm or not show_no_batchnorm)\n\n # TODO 'fc' should be renamed to 'mlp'.\n if 'fc' in allowed_nets and len(allowed_nets) == 1:\n warn('Network type \"fc\" is deprecated. Default value of argument ' +\n '\"allowed_nets\" will be changed to [\\'mlp\\'] in the future!',\n DeprecationWarning)\n elif 'fc' in allowed_nets:\n # TODO change warning into error at some point.\n warn('Network type \"fc\" is deprecated! Use \"mlp\" instead.',\n DeprecationWarning)\n if 'fc' in allowed_nets and 'mlp' in allowed_nets:\n # Doesn't make sense to have both.\n raise ValueError('Network type names \"fc\" and \"mlp\" refer to the ' +\n 'same network type! Note, \"fc\" is deprecated.')\n\n heading = 'Main network options'\n\n if prefix is None:\n prefix = ''\n pf_name = ''\n else:\n heading = 'Main network options for %s network' % pf_name\n pf_name += ' '\n\n # Abbreviations.\n p = prefix\n n = pf_name\n\n ### Main network options.\n agroup = parser.add_argument_group(heading)\n\n if len(allowed_nets) > 1:\n agroup.add_argument('--%snet_type' % p, type=str,\n default=allowed_nets[0],\n help='Type of network to be used for this %s ' % n +\n 'network. Default: %(default)s.',\n choices=allowed_nets)\n\n # DELETEME once we delete option 'fc'.\n if 'fc' in allowed_nets:\n agroup.add_argument('--%sfc_arch' % p, type=str, default=dfc_arch,\n help='If using a \"fc\" %s network, this will ' % n +\n 'specify the hidden layers. ' +\n 'Default: %(default)s.')\n\n if 'mlp' in allowed_nets:\n agroup.add_argument('--%smlp_arch' % p, type=str, default=dmlp_arch,\n help='If using a \"mlp\" %s network, this will ' % n +\n 'specify the hidden layers. ' +\n 'Default: %(default)s.')\n\n # Note, if you want to add more activation function choices here, you have\n # to add them to the corresponding function `utils.misc.str_to_act` as well!\n if show_net_act:\n agroup.add_argument('--%snet_act' % p, type=str, default=dnet_act,\n help='Activation function used in the %s network.' % n +\n 'If \"linear\", no activation function is used. ' +\n 'Default: %(default)s.',\n choices=['linear', 'sigmoid', 'relu', 'elu'])\n\n if show_no_bias:\n agroup.add_argument('--%sno_bias' % p, action='store_true',\n help='No biases will be used in the %s network. ' % n +\n 'Note, does not affect normalization (like ' +\n 'batchnorm).')\n\n if show_dropout_rate:\n agroup.add_argument('--%sdropout_rate' % p, type=float,\n default=ddropout_rate,\n help='Use dropout in the %s network with the ' % n +\n 'given dropout probability (dropout is ' +\n 'deactivated for a rate of -1). Default: ' +\n '%(default)s.')\n\n if show_specnorm:\n agroup.add_argument('--%sspecnorm' % p, action='store_true',\n help='Enable spectral normalization in the ' +\n '%s network.' % n)\n\n ### Batchnorm related options.\n if show_batchnorm:\n agroup.add_argument('--%sbatchnorm' % p, action='store_true',\n help='Enable batchnorm in the %s network.' % n)\n if show_no_batchnorm:\n agroup.add_argument('--%sno_batchnorm' % p, action='store_true',\n help='Disable batchnorm in the %s network.' % n)\n\n if show_bn_no_running_stats:\n agroup.add_argument('--%sbn_no_running_stats' % p, action='store_true',\n help='If batch normalization is used, then this ' +\n 'option will deactivate the tracking ' +\n 'of running statistics. Hence, statistics ' +\n 'computed per batch will be used during ' +\n 'evaluation.')\n\n if show_bn_distill_stats:\n agroup.add_argument('--%sbn_distill_stats' % p, action='store_true',\n help='If batch normalization is used, ' +\n 'then usually the running statistics are ' +\n 'checkpointed for every task (e.g., in ' +\n 'continual learning), which has linearly ' +\n 'increasing memory requirements. If ' +\n 'this option is activated, the running ' +\n 'statistics will be distilled into the ' +\n 'hypernetwork after training each task, ' +\n 'such that only the statistics of the ' +\n 'current and previous task have to be ' +\n 'explicitly kept in memory')\n\n if show_bn_no_stats_checkpointing:\n agroup.add_argument('--%sbn_no_stats_checkpointing' % p,\n action='store_true',\n help='If batch normalization is used, then' +\n 'this option will prevent the checkpointing' +\n 'of batchnorm statistics for every task.' +\n 'In this case, one set of statistics is ' +\n 'used for all tasks.')\n\n return agroup","async def man(self, ctx: Context, *, command: str) -> None:\n base_query = f\"https://www.mankier.com/api/v2/mans/?q={command}\"\n query_url = urllib.parse.quote_plus(base_query, safe=\";/?:@&=$,><-[]\")\n\n async with ctx.typing():\n # Get API query responses\n async with self.session.get(query_url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n results = json.loads(await response.text())[\"results\"]\n\n # Use first result\n if len(results) > 0:\n result = results[0]\n else:\n await ctx.send(\"Invalid query, no such command\")\n return\n\n base_url = f\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\"\n url = urllib.parse.quote_plus(base_url, safe=\";/?:@&=$,><-[]\")\n\n # Load man page from first result\n async with self.session.get(url) as response:\n if response.status != 200:\n await ctx.send(f\"An error occurred (status code: {response.status})\")\n return\n\n result = json.loads(await response.text())\n\n embed = Embed(\n title=f\"Man page of: **{result['name'].capitalize()}**\",\n url=result[\"url\"],\n description=f\"**{result['description']}** ({result['section']})\"\n )\n\n for anchor in result['anchors']:\n embed.add_field(\n name=f\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\",\n value=f\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\n[Link here]({anchor['url']})\",\n inline=False\n )\n # TODO: Solve this with pagination\n try:\n await ctx.send(embed=embed)\n except HTTPException as e:\n if e.code == 50035:\n await ctx.send(embed=Embed(\n description=\"Body is too long to show\",\n color=Color.red()\n ))\n else:\n raise e","def resnet110m(**kwargs):\r\n return ResNet(BasicBlock, 110, mask=True, **kwargs)","def export_mlp(self):\n return self.net","def magic_ll(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^l')","def parse():\n parser = argparse.ArgumentParser()\n parser.add_argument('--dataset', default='ml-1m', help='which dataset to use')\n args = parser.parse_args()\n main(args)","def test_lspci_nnmmv_ubuntu_20_10(self):\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_nnmmv'], quiet=True),\n self.f_json['ubuntu_20_10_lspci_nnmmv'])","def command(self, cmd):\n self.lmp.command(cmd)","def get_net(self,netname, mol = False):\n lines = self.mfp.get_net(netname)\n return lines","def label(cmd):\r\n cmd = cmd.replace('make][.DP', 'make1][.NP')\r\n cmd = cmd.replace('make][.SC', 'make2][.SC')\r\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\r\n cmd = '[result ' + cmd + ']' #dummy function for plop\r\n return cmd","def _mnasnet(arch, block, layers, expansions, kernel_sizes, SE, dropout=0,\n pretrained=False, progress=False, **kwargs):\n model = MnasNet(block, layers=layers, expansions=expansions, kernel_sizes=kernel_sizes,\n SE=SE, dropout=dropout, **kwargs)\n if pretrained:\n if arch in model_urls.keys():\n state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)\n model.load_state_dict(state_dict)\n return model","def netz(self, mask, target, args):\n print('{mask} netz {args}'.format(mask=mask, args=args))\n nick = args['<nick>']\n if nick is None:\n nick = mask.nick\n yield self.bot.db.get(nick, {}).get('netz', None) or 'Nichts bekannt über {nick}'.format(nick=nick)","def maml(self, line, cell):\n parser = self.get_parser(CsMLMagics.maml_parser, \"maml\")\n args = self.get_args(line, parser)\n\n if args is not None:\n quiet = args.quiet\n out, err = maml(cell, not quiet)\n if out:\n print(out)\n if err:\n print('-----')\n print(err)","def get_cmd():\n parser = argparse.ArgumentParser()\n parser.add_argument(\"-i\", action=\"store\", dest=\"inputfile\", help=\"file with multiple hmm models\")\n parser.add_argument(\"-o\", action=\"store\", dest=\"dirout\", help=\"directory to store separated hmm models\")\n params = parser.parse_args()\n return params","def label(cmd):\n cmd = cmd.replace('make][.DP', 'make1][.NP')\n cmd = cmd.replace('make][.SC', 'make2][.SC')\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\n cmd = '[result ' + cmd + ']' #dummy function for plop\n return cmd","def _magic_n(self, args):\n if idapy._d is None:\n print \"Please select a dump first. Example:\"\n print \"sel t2i\"\n return\n args = args.split(\" \")\n s,n = string.join(args[:-1], \" \"), args[-1]\n \n a = addr_from_magic_string(s, rounded_32bit = False)\n print \"NSTUB( 0x%X, %s )\" % (a, n)\n idapy._d.MakeName(a, n)","def _llm_type(self) -> str:\n return \"openai\"","def parse_misc(self,ins):\n if ins.instr == 'nop':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'syscall':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'break':\n if len(ins.args) != 0:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n elif ins.instr == 'mflo': \n if len(ins.args) == 1:\n self.gen = [ins.args[0]]\n self.need = [Register(\"$lo\")]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mtlo': \n if len(ins.args) == 1:\n self.gen = [Register(\"$lo\")]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mfhi': \n if len(ins.args) == 1:\n self.gen = [ins.args[0]]\n self.need = [Register(\"$hi\")]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mthi': \n if len(ins.args) == 1:\n self.gen = [Register(\"$hi\")]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'mtc1': \n if len(ins.args) == 2:\n self.gen = [ins.args[1]]\n self.need = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mfc1': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.need = [ins.args[1]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'la': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.ival = ins.args[1]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'lui': \n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.ival = ins.args[1]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)","def _command(f, wrapper, syntax, namespace, internal=False):\n logger.info('command : syntax : {0}'.format(syntax))\n node = Tree.fnode(f, wrapper)\n node.command.syntax = syntax\n node.command.internal = internal\n if namespace:\n Tree().rename_node(node.name, '{0}.{1}'.format(namespace, f.__qualname__))\n node.command.build_command_parsing_tree()","def _llm_type(self) -> str:\n return \"llama.cpp\"","def __init__(self, entityTypes, tokenClassifier):\n Finder.__init__(self, entityTypes)\n self.tokenClassifier = tokenClassifier\n if self.tokenClassifier != None:\n self.finderType = 'mention.'+self.tokenClassifier.classifierType\n else:\n self.finderType = 'mention'","def autosuggest_ml(self, suggest, focus=None, clip=None, display='full',\n format='json', lang=None):\n\n params = {\n 'addr': suggest,\n 'display': display,\n 'format': format,\n 'lang': lang or self.lang,\n }\n if focus:\n params.update({\n 'focus': focus\n })\n if clip:\n params.update({\n 'clip': clip\n })\n\n return self._request('/autosuggest-ml', params)","def cmd_mdtm(args):","def ReadNet(model_def):\n with open(model_def) as f:\n net = cp.NetParameter()\n pb.text_format.Parse(f.read(), net)\n return net","def meinnetz(self, mask, target, args):\n print('{mask} meinnetz {args}'.format(mask=mask, args=args))\n netz = args['<netz>'] or None\n if netz is not None:\n netz = ' '.join(netz)\n self.bot.db.set(mask.nick, netz=netz)\n yield 'ack'","def _from_command_line():\n # Manim can be called from the command line in three different\n # ways. The first two involve using the manim or manimcm commands\n prog = os.path.split(sys.argv[0])[-1]\n from_cli_command = prog in [\"manim\", \"manimcm\"]\n\n # The third way involves using `python -m manim ...`. In this\n # case, the CLI arguments passed to manim do not include 'manim',\n # 'manimcm', or even 'python'. However, the -m flag will always\n # be the first argument.\n from_python_m = sys.argv[0] == \"-m\"\n\n return from_cli_command or from_python_m","def but_load_net(self):\n a = tk.filedialog.askopenfilename(filetypes = [('NN file',['*.csv','*.pt'])])\n self.nn_obj=load_nn(a)","def interpret_nl(nl_string):\n if nl_string == 'relu':\n return tf.nn.relu\n elif nl_string == 'sigmoid':\n return tf.sigmoid\n elif nl_string == 'tanh':\n return tf.tanh\n else:\n raise NotImplementedError(nl_string)","def mobilenetv1(**kwargs):\n return MobileNet(**kwargs)","def parseargs(p):\n p.set_defaults(func=func)\n p.description = \"Print machine architecture.\"\n return p","def get_command(self, kword: str):\n # Step Zero is to make sure that the name does not belong to a REAL command.\n zero, mod = super().get_command(kword)\n if zero:\n return zero, mod\n\n # Otherwise, first, ensure that the keyword does in fact exist in the custom list.\n command = self.config.commands.get(kword, None)\n if not command:\n return None, None\n response = command[\"com\"]\n\n # Build the function to return the response. Note that \"self\" exists already.\n async def cmd_custom(args, src, **_):\n if args:\n member = self.get_member(src, args[0].strip())\n tag = member.mention if member else None\n else:\n tag = None\n\n nsfw = command.get(\"nsfw\", False)\n if nsfw and src.channel.id not in self.config.get(\"nsfwChannels\"):\n return None\n\n # Replace tags where needed.\n try:\n output = response.format(\n self=src.author.name,\n myID=src.author.id,\n tag=tag or src.author.mention,\n )\n except KeyError:\n return None\n else:\n return output\n\n # Specify the docstring and name so that !help will work on this.\n short = response.replace(\"{\", \"{{\").replace(\"}\", \"}}\")\n if len(short) > 80:\n short = short[:77] + \"...\"\n cmd_custom.__doc__ = (\n \"__Custom command__: Return the following text: ```{}```\\n\\n\".format(short)\n + command.get(\n \"desc\",\n \"This is a custom command, so available help text is limited, but at the same time, the command is very simple. All it does is return a string, although the string may include formatting tags for invoker name, invoker ID, and a targeted mention.\",\n )\n + \"\\n\\nSyntax: `{p}\"\n + kword.lower()\n + (\" <user_ID>\" if \"{tag}\" in response else \"\")\n + \"`\"\n )\n cmd_custom.__name__ = \"cmd_\" + kword.lower()\n\n return cmd_custom, None","def config_megam(bin: Optional[Any] = ...):\n ...","def getArbitraryManInput(self):\n return \"\"\".TH MANHOLE \"1\" \"August 2001\" \"\" \"\"\n.SH NAME\nmanhole \\- Connect to a Twisted Manhole service\n.SH SYNOPSIS\n.B manhole\n.SH DESCRIPTION\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\ncode as if at an interactive Python console inside a running Twisted process\nwith this.\"\"\"","def test_findlike():\n parser = CmdParser([findlike])\n out = parser.parse(\"findlike . -name foo\")\n assert out[0].arguments[0].present == True\n assert out[0].arguments[0].value == \"foo\"\n assert out[0].arguments[1].present == True\n assert out[0].arguments[1].value == \".\"\n assert out[0].as_shell_string() == \"findlike . -name foo\"","def test_set_node_name_for_matmul_add_linear(self, export_args):\n class Linear(torch.nn.Module):\n def __init__(self):\n super(Linear, self).__init__()\n self.linear = torch.nn.Linear(3, 2)\n\n def forward(self, inp):\n x = self.linear(inp)\n return x\n\n model = Linear()\n # Using an input to linear op with dimension != 2 causes torch to use matmul->add instead of gemm op\n onnx_path = './data/MyModel.onnx'\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 1, 3), onnx_export_args=copy.deepcopy(export_args))\n onnx_model = onnx.load(onnx_path)\n expected_node_names = ['linear', 'linear#1.end']\n\n actual_node_names = [node.name for node in onnx_model.graph.node]\n for name in expected_node_names:\n assert name in actual_node_names\n\n expected_param_names = ['linear.weight', 'linear.bias']\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\n for name in expected_param_names:\n assert name in valid_param_set\n\n # Check that gemm still works as expected\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 3), onnx_export_args=copy.deepcopy(export_args))\n onnx_model = onnx.load(onnx_path)\n\n actual_node_names = [node.name for node in onnx_model.graph.node]\n assert 'linear' in actual_node_names\n assert 'linear#1' not in actual_node_names\n\n expected_param_names = ['linear.weight', 'linear.bias']\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\n for name in expected_param_names:\n assert name in valid_param_set\n\n self.check_onnx_node_name_uniqueness(onnx_model)\n\n if os.path.exists(onnx_path):\n os.remove(onnx_path)","def __init__(self, node):\n super(LAMMPSBaseParser, self).__init__(node)","def want_label(self, op):\n return self.want_line(r'\\s*\\S*(%s)\\S*\\:.*' % (op))","def cmd_type(args):","def parsingcommands(self):\n parser = argparse.ArgumentParser(\n description=\"httpfs is a simple file server.\")\n parser.add_argument(\"-v\", action=\"store_true\", dest=\"debug\",\n help=\"Prints debugging messages.\", default=False)\n parser.add_argument(\"-p\", action=\"store\", dest=\"port\",\n help=\"Specifies the port number that the server will listen and serve at. Default is 8080.\",\n type=int, default=8080)\n parser.add_argument(\"-d\", action=\"store\", dest=\"path_to_dir\",\n help=\"Specifies the directory that the server will use to read/writerequested files. \\\n Default is the current directory when launching theapplication.\",\n default='./')\n parser.add_argument(\"-arq\", action='store_true', dest=\"arq\", default=False, help=\"Automatic-Repeat-Request (ARQ)\")\n\n return parser.parse_args()","def get_default_MXNet_mode():\n return MXNET_DEFAULT_MODE","def parse_args(default_minppmm=1000):\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\n parser.add_argument(\"-p\", \"--plumedir\", required=True,\n help=\"path to input plume file directory\")\n parser.add_argument(\"-r\", \"--regex\", required=False,\n default=\"ang.*_detections/ime_minppmm{}/ang.*_ime_minppmm{}.*\".format(\n default_minppmm, default_minppmm),\n help=\"Regular expression to match for plume files\")\n parser.add_argument(\"-w\", \"--windir\", required=True,\n help=\"path to input wind file directory\")\n parser.add_argument(\"-o\", \"--outfile\", required=True,\n help=\"path to output plume list\")\n parser.add_argument(\"-f\", \"--force\",\n help=\"Force reprocessing of all files (not just the new ones)\",\n action='store_true')\n parser.add_argument(\"-n\", \"--nprocs\", type=int, default=1,\n help=\"number of parallel processes to use; default=1 (sequential)\")\n parser.add_argument(\"--flmode\",\n help=\"Executes script in flightline mode, running on a single flightline\",\n action=\"store_true\")\n args = parser.parse_args()\n return (args.plumedir, args.regex, args.windir, args.outfile,\n args.force, args.nprocs, args.flmode)","def parse(self, args):\r\n # handle `sl ...`\r\n main_args = self.parse_main_args(args)\r\n module_name = main_args['<module>']\r\n\r\n # handle `sl <module> ...`\r\n module_args = self.parse_module_args(module_name, main_args['<args>'])\r\n\r\n # get the command argument\r\n command_name = module_args.get('<command>')\r\n\r\n # handle `sl <module> <command> ...`\r\n return self.parse_command_args(\r\n module_name,\r\n command_name,\r\n main_args['<args>'])","def do_mdns(self, line):\n listener = MdnsListener()\n boards = listener.listen(seconds=1)\n if len(boards) == 0:\n print(\"No board out there waving it's flag ...\")\n return\n print(\"url ip port spec\")\n for b in boards:\n print(\"{:20s} {:14s} {:2d} {}\".format(\n b.url, b.ip, b.port, b.spec))","def lncli(cmd, node_index):\n node = Node.from_index(node_index)\n run_lncli(node, cmd)","def train_mann_multi(args):\n\n src = args.src\n tgt = args.tgt\n base_model = args.base_model\n num_cls = args.num_cls\n tgt_list = args.tgt_list\n num_epoch = args.mann_num_epoch\n batch = args.batch\n datadir = args.datadir\n outdir = args.outdir_mann\n src_weights = args.src_net_file\n lr = args.mann_lr\n betas = tuple(args.betas)\n weight_decay = args.weight_decay\n centroids_path = args.centroids_src_file\n feat_dim = 512\n\n ###########################\n # Setup cuda and networks #\n ###########################\n\n # setup cuda\n if torch.cuda.is_available():\n kwargs = {'num_workers': 8, 'pin_memory': True}\n else:\n kwargs = {}\n\n # setup network \n net = get_model('MannNet', model=base_model, num_cls=num_cls,\n src_weights_init=src_weights,\n centroids_path=centroids_path, feat_dim=feat_dim)\n \n # print network and arguments\n print(net)\n print('Training Mann {} model for {}->{}'.format(base_model, src, tgt))\n\n #######################################\n # Setup data for training and testing #\n #######################################\n train_src_data = load_data_multi(src, 'train', batch=batch,\n rootdir=join(datadir, src), num_channels=net.num_channels,\n image_size=net.image_size, download=True, kwargs=kwargs)\n\n train_tgt_data = load_data_multi(tgt_list, 'train', batch=batch, \n rootdir=datadir, num_channels=net.num_channels,\n image_size=net.image_size, download=True, kwargs=kwargs)\n\n ######################\n # Optimization setup #\n ######################\n opt_net = optim.Adam(net.tgt_net.parameters(), lr=lr, \n weight_decay=weight_decay, betas=betas)\n opt_dis = optim.Adam(net.discriminator.parameters(), lr=lr, \n weight_decay=weight_decay, betas=betas)\n opt_selector = optim.Adam(net.fc_selector.parameters(), lr=lr*0.1, \n weight_decay=weight_decay, betas=betas)\n opt_classifier = optim.Adam(net.classifier.parameters(), lr=lr*0.1, \n weight_decay=weight_decay, betas=betas)\n\n ##############\n # Train mann #\n ##############\n for epoch in range(num_epoch):\n err = train_epoch(train_src_data, train_tgt_data, net, opt_net, opt_dis, opt_selector, opt_classifier, epoch) \n if err == -1:\n print(\"No suitable discriminator\")\n break\n \n ##############\n # Save Model #\n ##############\n os.makedirs(outdir, exist_ok=True)\n outfile = join(outdir, 'mann_{:s}_net_{:s}_{:s}.pth'.format(base_model, src, tgt))\n print('Saving to', outfile)\n net.save(outfile)","def __init__(self, *args):\n _snap.TMMNet_swiginit(self, _snap.new_TMMNet(*args))","def graph_cmd(args):\n\n # charge graphviz\n Digraph = load_graphviz()\n\n view = True\n for i in args:\n if i == \"noview\":\n view = False\n args.remove(i)\n break\n\n if len(args) > 0:\n if len(args) >= 2:\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \"traverse\":args[1], \"mibs\":\"base\" })\n else:\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \"mibs\":\"base\" })\n else:\n r = requete('NeMo.Intf.lo:getMIBs', { \"traverse\":\"all\", \"mibs\":\"base\" })\n if r is None: return\n if not 'status' in r or not 'base' in r['status']: return\n r = r['status']['base']\n\n dot = Digraph(name='NeMo.Intf', format='svg', engine='dot')\n\n dot.attr('node', fontname='Helvetica')\n #dot.attr('node', fontname='Times-Roman')\n\n for i, node in r.items():\n #dot.attr('node', tooltip=v['Flags'] if 'Flags' in v else '')\n if 'Enable' in node:\n if node['Enable'] == True:\n dot.node(i, shape='box')\n else:\n dot.node(i, shape='ellipse', color='lightgrey')\n else:\n dot.node(i, shape='box', color='lightgrey')\n\n for i, v in r.items():\n for j in v['LLIntf']:\n dot.edge(i, j)\n\n dot.render(filename=\"nemo_intf.gv\", view=view)","def parse_cmd_args():\n parser = argparse.ArgumentParser()\n parser.add_argument('-m', '--path_model', type=str, help='Path to trained model.')\n parser.add_argument('-t', '--type', type=str, help='Either \"torch\" or \"sklearn\".')\n # parser.add_argument('-l', '--location', type=str, help='Either \"local\", \"midgard\" or \"rattle\"')\n parser.add_argument('-i', '--path_in', type=str, help='Path to input file.')\n parser.add_argument('-o', '--path_out', type=str, help='Path to output file.')\n parser.add_argument('-c', '--path_config', type=str, help='Path to config file.')\n parser.add_argument('-g', '--gpu', type=int, default=0, help='Number of the gpu to be used.')\n return parser.parse_args()","def parse(self, message, prefix, cmd_list):\n\n self.parse_type = \"\"\n self.parse_msg = []\n for i in message:\n if i[0].isdigit():\n self.parse_number(i, \"w\")\n elif len(i) == 1:\n self.parse_type += \"w\"\n self.parse_msg.append(i)\n elif i == \"@everyone\" or i == \"@here\":\n self.parse_type += \"s\"\n self.parse_msg.append(i)\n elif i[0] == prefix:\n self.parse_command(i, cmd_list)\n elif i[0] == \"-\":\n self.parse_number(i, \"o\")\n elif i[0] == \"<\" and len(i) > 3:\n self.parse_mention(i)\n else:\n self.parse_type += \"w\"\n self.parse_msg.append(i[(i[0] == \"\\\\\"):])","def mgcNetArch(self, **kwargs):\n\n def_vals = {\"input_img_rows\" : self.input_img_rows,\n \"input_img_cols\" : self.input_img_cols,\n \"channels\" : self.channels,\n \"nb_classes\" : self.nb_classes,\n \"outLayer\" : 'gloAvg', \n \"l2_val\" : 0.00, \n \"net_architr\" : 'cnn_max', \n \"block_typex\" : 'basic', \n \"block_repeatx\" : [1, 1]\n }\n\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n _input_img_rows = kwargs['input_img_rows']\n _input_img_cols = kwargs['input_img_cols']\n _channels = kwargs['channels']\n _nb_classes = kwargs['nb_classes']\n _outLayer = kwargs['outLayer']\n _l2_val = kwargs['l2_val']\n _net_architr = kwargs['net_architr']\n _block_typex = kwargs['block_typex']\n _block_repeatx = kwargs['block_repeatx']\n \n \n params = {\"input_img_rows\" : _input_img_rows,\n \"input_img_cols\" : _input_img_cols,\n \"channels\" : _channels,\n \"nb_classes\" : _nb_classes\n }\n \n print(_net_architr)\n if _net_architr == 'cnn_max':\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'cnn_stride':\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'cnn_stride_mini':\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'common_cnn':\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'net_in_net':\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'resnet':\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\n \n elif _net_architr == 'resblock':\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'skipconnect':\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\n elif _net_architr == 'skipconnect_mini':\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n self.model = model\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\n #self.model_summary = model.summary() \n \n return self","def cmd(self, cmd):\n return cmd","def mod_command(server, output):\n for target in output.message.split()[1:]:\n if target in server.ops:\n server.tell(output.name, '%s is an operator' % (target))\n continue\n if target in server.mods:\n server.tell(output.name, '%s is already a mod' % (target))\n else:\n server.mod(output, target)\n return","def netlogo_args():\n return {\n \"model\": \"/home/smitty/proj/css600transp/css600transp/FireSim.nlogo\",\n \"setup-file\": \"setup-file.xml\",\n \"experiment\": \"FireSim\",\n \"threads\": \"1\",\n \"table\": \"-\",\n }","def handle_magic(self, line, continue_prompt=None,\n pre=None,iFun=None,theRest=None):\n\n cmd = '%sipmagic(\"%s\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\n self.log(cmd,continue_prompt)\n self.update_cache(line)\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\n return cmd","def arg_parsing():\n\n # parser instance\n parser = argparse.ArgumentParser(description=\"Neural Network Settings\")\n\n # select data directory\n parser.add_argument('--data_dir', \n type=str, \n help='Data directory.')\n \n # select architecture\n parser.add_argument('--arch', \n type=str, \n help='Choose architecture from torchvision.models')\n \n # select directory\n parser.add_argument('--save_dir', \n type=str, \n help='Saving directory path for checkpoints.')\n \n # set hyperparameters\n parser.add_argument('--learning_rate', \n type=float, \n help='Gradient descent learning rate')\n parser.add_argument('--hidden_units', \n type=int, \n help='Number of hidden layers for DNN.')\n parser.add_argument('--epochs', \n type=int, \n help='Number of epochs for training.')\n\n # set gpu option\n parser.add_argument('--gpu', \n action=\"store_true\", \n help='Use GPU.')\n \n # args\n args = parser.parse_args()\n \n return args","def build_command(args, parser):\n cmd = \"ipmitool -I lanplus\"\n if not args.host:\n print \"\\nERROR: hostname is required.\\n\"\n parser.print_help()\n sys.exit(1)\n else:\n cmd += ' -H ' + args.host\n if args.port:\n cmd += ' -p ' + args.port\n if not args.user:\n print \"\\nERROR: username is required.\\n\"\n parser.print_help()\n sys.exit(1)\n else:\n cmd += ' -U ' + args.user\n if args.passwd:\n cmd += ' -P ' + args.passwd\n cmd += ' dcmi power reading'\n if args.interval:\n global INTERVAL\n INTERVAL = args.interval\n if args.nread:\n global NREAD\n NREAD = args.nread\n else:\n global INFINITY\n INFINITY = True\n if args.store:\n global STORE\n STORE = True\n return cmd","def intf_MMLIST(E):\n print(MMEL.__repr__())\n #print(OUT.default(MMEL,E))","def parse_cl():\n import argparse\n\n parser = argparse.ArgumentParser(description='')\n parser.add_argument('--lef', action=\"store\", dest='src_lef', required=True)\n parser.add_argument('--def', action=\"store\", dest='src_def', required=True)\n parser.add_argument('--verilog', action=\"store\", dest='src_v', required=True)\n parser.add_argument('--pl', action=\"store\", dest='final_pl')\n parser.add_argument('--def_out', action=\"store\", dest='dest_def', default='out.def')\n\n opt = parser.parse_args()\n\n return opt","def parse(self, args):\n pass","def magic_lsmagic(self, parameter_s = ''):\n print 'Available magic functions:\\n@'+' @'.join(self.lsmagic())\n print '\\n' + Magic.auto_status[self.rc.automagic]\n return None","def parse(self, commands):\n raise NotImplementedError()","def decomp(net):\n \n pt_netname = Word(alphanums) + Suppress('_') + restOfLine\n pt_netnamebus = Word(alphanums) + Suppress('_') + Word(alphanums+'_') + \\\n Suppress('[') + Word(nums) + Suppress(']')\n parser = (pt_netnamebus | pt_netname)\n \n return parser.parseString(net)","def __init__(self, *args):\n _snap.TMMNetModeNetI_swiginit(self, _snap.new_TMMNetModeNetI(*args))","def cmdline(self):\r\n raise NotImplementedError","def test_lspci_nmmv_ubuntu_20_10(self):\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_nmmv'], quiet=True),\n self.f_json['ubuntu_20_10_lspci_nmmv'])","def _register_commands(self):\n cmds = []\n cmd_help = CommandParser(\"help\", \"Show help for a command.\")\n cmd_help.add_argument(\n \"command\",\n nargs=\"*\",\n help=\"The command to get help for. Specify multiple names to get help for subcommands.\",\n )\n cmd_help.add_argument(\"-m\", \"--module\", help=\"List all commands from the given module\")\n cmd_help.add_argument(\n \"-f\",\n \"--full\",\n action=\"store_true\",\n help='Include descriptions in the \"all\" help output.',\n )\n cmds.append(cmd_help)\n\n target_mod = CommandParser()\n target_mod.add_argument(\"module\", nargs=\"+\", help=\"Target module(s)\")\n target_mod.add_argument(\n \"-p\",\n \"--protocol\",\n action=\"store_const\",\n const=\"protocol\",\n default=\"feature\",\n dest=\"mtype\",\n help=\"Target is a protocol module\",\n )\n cmd_module = CommandParser(\"module\", \"Manage and query ZeroBot modules\")\n add_subcmd = cmd_module.make_adder(metavar=\"OPERATION\", dest=\"subcmd\", required=True)\n add_subcmd(\"load\", description=\"Load a module\", parents=[target_mod])\n add_subcmd(\"reload\", description=\"Reload a module\", parents=[target_mod])\n subcmd_list = add_subcmd(\"list\", description=\"List available modules\")\n subcmd_list.add_argument(\"-l\", \"--loaded\", action=\"store_true\", help=\"Only loaded modules\")\n list_group = subcmd_list.add_mutually_exclusive_group()\n default_categories = [\"protocol\", \"feature\"]\n list_group.add_argument(\n \"-f\",\n \"--feature\",\n action=\"store_const\",\n const=[\"feature\"],\n dest=\"category\",\n default=default_categories,\n help=\"Only feature modules\",\n )\n list_group.add_argument(\n \"-p\",\n \"--protocol\",\n action=\"store_const\",\n const=[\"protocol\"],\n dest=\"category\",\n default=default_categories,\n help=\"Only protocol modules\",\n )\n add_subcmd(\"info\", description=\"Show module information\", parents=[target_mod])\n cmds.append(cmd_module)\n\n save_reload_args = CommandParser()\n save_reload_args.add_argument(\n \"config_file\",\n nargs=\"*\",\n help=\"Name of config file (without .toml extension). Omit to affect all loaded config files.\",\n )\n set_reset_args = CommandParser()\n set_reset_args.add_argument(\"config_file\", help=\"Name of config file (without .toml extension)\")\n cmd_config = CommandParser(\"config\", \"Manage configuration\")\n add_subcmd = cmd_config.make_adder(metavar=\"OPERATION\", dest=\"subcmd\", required=True)\n add_subcmd(\"save\", description=\"Save config files to disk\", parents=[save_reload_args])\n subcmd_savenew = add_subcmd(\"savenew\", description=\"Save config file to a new path\")\n subcmd_savenew.add_argument(\"config_file\", help=\"Name of config file (without .toml extension)\")\n subcmd_savenew.add_argument(\"new_path\", help=\"The path to save the config file to\")\n add_subcmd(\n \"reload\",\n description=\"Reload config files from disk\",\n parents=[save_reload_args],\n )\n subcmd_set = add_subcmd(\"set\", description=\"Modify config settings\", parents=[set_reset_args])\n subcmd_set.add_argument(\n \"key_path\",\n help=\"The config key to set. Subkeys are separated by dots, e.g. 'Core.Backup.Filename'\",\n )\n subcmd_set.add_argument(\"value\", nargs=\"?\", help=\"The new value. Omit to show the current value.\")\n subcmd_reset = add_subcmd(\n \"reset\",\n description=\"Reset config settings to last loaded value\",\n parents=[set_reset_args],\n )\n subcmd_reset.add_argument(\n \"key_path\",\n nargs=\"?\",\n help=(\n \"The config key to set. Subkeys are separated by dots, \"\n \"e.g. 'Core.Backup.Filename'. If omitted, the entire \"\n \"config will be reset.\"\n ),\n )\n subcmd_reset.add_argument(\n \"-d\",\n \"--default\",\n action=\"store_true\",\n help=\"Set the key to its default value instead. Effectively unsets a config key.\",\n )\n cmds.append(cmd_config)\n\n cmd_version = CommandParser(\"version\", \"Show version information\")\n cmds.append(cmd_version)\n\n cmd_restart = CommandParser(\"restart\", \"Restart ZeroBot.\")\n cmd_restart.add_argument(\"msg\", nargs=\"*\", help=\"Message sent to protocol modules as a reason\")\n cmds.append(cmd_restart)\n\n cmd_quit = CommandParser(\"quit\", \"Shut down ZeroBot.\")\n cmd_quit.add_argument(\"msg\", nargs=\"*\", help=\"Message sent to protocol modules as a reason\")\n cmds.append(cmd_quit)\n\n cmd_wait = CommandParser(\"wait\", \"Execute a command after a delay\")\n cmd_wait.add_argument(\n \"delay\",\n help=\"Amount of time to delay. Accepts the following modifier suffixes: 'ms', 's' (default), 'm', 'h'.\",\n )\n cmd_wait.add_argument(\"command\", help=\"Command to delay\")\n cmd_wait.add_argument(\"args\", nargs=argparse.REMAINDER, help=\"Command arguments\")\n cmds.append(cmd_wait)\n\n cmd_cancel = CommandParser(\"cancel\", \"Cancel a waiting command\")\n cancel_group = cmd_cancel.add_mutually_exclusive_group()\n cancel_group.add_argument(\"id\", type=int, nargs=\"?\", help=\"The ID of a waiting command\")\n cancel_group.add_argument(\"-l\", \"--list\", action=\"store_true\", help=\"List currently waiting commands\")\n cmds.append(cmd_cancel)\n\n cmd_backup = CommandParser(\"backup\", \"Create a database backup\")\n cmd_backup.add_argument(\"name\", type=Path, help=\"Backup filename\")\n cmds.append(cmd_backup)\n\n self.command_register(\"core\", *cmds)","def parse_cmd(cmd):\n begin_pat = re.compile(r'BEGIN\\s*\\{(.+?)\\}\\s*;?', re.X | re.S)\n end_pat = re.compile(r'END\\s*\\{(.+?)\\}\\s*;?', re.X | re.S)\n normal_pat = re.compile(r'([^{]*)(\\{(.+?)\\})?\\s*;?', re.X | re.S)\n\n # get BEGIN part\n begin = u''\n m = begin_pat.search(cmd)\n if m:\n begin = m.group(1).strip()\n cmd = cmd.replace(m.group(0), u'')\n\n # get END part\n end = u''\n m = end_pat.search(cmd)\n if m:\n end = m.group(1).strip()\n cmd = cmd.replace(m.group(0), u'')\n\n # get NORMAL part\n normal = (u'', u'')\n m = normal_pat.search(cmd)\n if m:\n pattern = m.group(1) or u'' # get u'' if \\1 is None\n action = m.group(3) or u'' # get u'' if \\3 is None\n normal = (pattern.strip(), action.strip())\n\n return (begin, normal, end)","def __init__(self):\n self.label = \"Neural network input files\"\n self.description = \"Use this tool to create the input ASCII files for the GeoXplore neural network. Before using this tool, the evidence must be combined into a unique conditions raster with the Combine tool and the band statistics must be obtained for all the evidence using the Band Collection Statistics tool. If desired fuzzy membership attribute can be added to each of the training sites. See the ArcMap Tools Options discussion in Usage Tips in the Help about adjusting default setting for this tool.\"\n self.canRunInBackground = False\n self.category = \"Neural network\"","def parse_args():\n parser = common.default_args(net_name=NET_NAME, \n num_classes=21, image_size=IMAGE_SIZE)\n parser.add_argument('--trained-model', required=False, help='Path to trained state_dict file', \n default=TRAINED_MODEL_PATH)\n return parser.parse_args()","def commandParser(self, testtype, command):\n if testtype == 'command':\n if type(command) == types.StringType:\n # Type is a string: it has to be transformed into a list\n l = command.split(\" \")\n pos = 0\n for i in l:\n if (i.startswith('%') and i.endswith('%')):\n # if item contains environment variable (e.g. %nmap%), it is replaced with its value (config.cfg)\n if(i == \"%target%\"):\n l[pos] = self._target\n elif(self.config.has_option('ENV',i.replace('%',''))):\n l[pos] = self.config.get('ENV',i.replace('%',''))\n else:\n print \"\"\"***ERROR: Environment variable not found in command %s\"\"\" % command\n sys.exit()\n pos += 1\n elif type(command) == types.ListType:\n # Type is a list: nothing to do\n l = command\n else:\n print \"\"\"***ERROR: Syntax error for command %s\"\"\" % command\n sys.exit()\n return l\n else:\n envlist = self.config.options('ENV')\n tmp = command\n # Replace every eventual reference to an environment variable\n for envvar in envlist:\n tmp = tmp.replace(\"%\"+envvar+\"%\", self.config.get('ENV', envvar))\n # Replace %target% keyword\n tmp = tmp.replace('%target%', self._target)\n return tmp","def __getFullCommandName(self, command, type):\n return 'cmd_%s_%s' % (type, command)","def parse(string: str) -> 'NbfCommand':\n part_strs = string.split('_')\n if len(part_strs) != 3:\n raise NbfParseError(f\"nbf command \\\"{string}\\\" malformed, should have exactly three parts\")\n\n opcode_str, addr_str, data_str = part_strs\n try:\n opcode = int(opcode_str, 16)\n addr = reverse_bytes(bytes.fromhex(addr_str))\n data = reverse_bytes(bytes.fromhex(data_str))\n except ValueError:\n raise NbfParseError(f\"nbf command \\\"{string}\\\" malformed, contains invalid hex bytes\")\n\n if len(addr) != ADDRESS_LENGTH_BYTES:\n raise NbfParseError(f\"nbf command \\\"{string}\\\" malformed, address must be exactly {ADDRESS_LENGTH_BYTES} bytes\")\n\n if len(data) != DATA_LENGTH_BYTES:\n raise NbfParseError(f\"nbf command \\\"{string}\\\" malformed, data must be exactly {DATA_LENGTH_BYTES} bytes\")\n\n return NbfCommand(opcode, addr, data)","def mt_classifier(input_file, muscle_exec, basename, best_results):\n pass","def metaphor_magnet(word):\r\n try:\r\n link = \"http://ngrams.ucd.ie/metaphor-magnet-acl/q?kw=\" + word\r\n f = urllib.request.urlopen(link)\r\n myfile = f.read()\r\n myfile = myfile.decode()\r\n data = myfile[myfile.index(\"data.setCell\"):myfile.rindex(\"data.setCell\")]\r\n data = data.split(\"data.setCell\")\r\n choice = 1\r\n magnet_list = []\r\n while choice < len(data)-1:\r\n words = data[choice][data[choice].index(\"\\\"\")+1:data[choice].rindex(\",\")]\r\n magnet_list.append(words)\r\n choice +=3 \r\n \r\n return magnet_list\r\n # if nothing is found, try again with a different word\r\n except ValueError:\r\n choice = random.randint(0,len(RAND_LIST)-1)\r\n return metaphor_magnet(RAND_LIST[choice])","def test_support_NETWORK(self):\n self.assertEqual(self._parseFeature(\"NETWORK\", \"IRCNet\"), \"IRCNet\")","def __getattr__(self, cmd):\n\n if hasattr(self._rpc, cmd+'Request'):\n lnfunc = getattr(self._rpc, cmd+'Request')\n elif hasattr(self._rpc, f'Get{cmd}Request'):\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\n else:\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\n\n if hasattr(self._stub, cmd):\n stubfunc = getattr(self._stub, cmd)\n\n def rpcCommand(*args,**kwargs):\n return stubfunc(lnfunc(*args, **kwargs))\n return rpcCommand\n\n elif hasattr(self._stub, 'Get'+cmd):\n stubfunc = getattr(self._stub, 'Get'+cmd)\n def rpcCommand(*args,**kwargs):\n if args:\n raise TypeError('Cannot use positional arguments with this command')\n return stubfunc(lnfunc(**kwargs))\n return rpcCommand\n\n else:\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)","def network(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"network\")","def test_rename_to_mlflow(mlflow):\n atom = ATOMClassifier(X_bin, y_bin, experiment=\"test\", random_state=1)\n atom.run(\"GNB\")\n atom.scoring()\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training","def ftp_MLST(self, line):\n # if no argument, fall back on cwd as default\n if not line:\n line = self.fs.cwd\n path = self.fs.ftp2fs(line)\n line = self.fs.ftpnorm(line)\n basedir, basename = os.path.split(path)\n try:\n data = self.fs.format_mlsx(basedir, [basename], ignore_err=False)\n except OSError, err:\n why = _strerror(err)\n self.log('FAIL MLST \"%s\". %s.' %(line, why))\n self.respond('550 %s.' %why)\n else:\n # where TVFS is supported, a fully qualified pathname\n # should be returned\n data = data.split(' ')[0] + ' %s\\r\\n'%line\n # response is expected on the command channel\n self.push('250-Listing \"%s\":\\r\\n' %line)\n # the fact set must be preceded by a space\n self.push(' ' + data)\n self.respond('250 End MLST.')","def parse_ls(self,ins):\n global Creg\n if ins.instr == 'lb':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1])\n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'lbu':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'lh':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'lhu':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'lw':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n \n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'dlw':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.gen = self.double_reg(ins.args[0])\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'dmfc1':\n if len(ins.args) == 2:\n self.need = [ins.args[1]] \n self.gen = self.double_reg(ins.args[0])\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'l.s':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n \n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'l.d':\n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n \n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'sb': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.need = [ins.args[0]] + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)\n \n elif ins.instr == 'sbu': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1])\n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.need = [ins.args[0]] + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'sh': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1])\n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.need = [ins.args[0]] + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'shu': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.need = [ins.args[0]] + self.need \n \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'sw': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.need = [ins.args[0]] + self.need\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'dsw': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.need = self.double_reg(ins.args[0]) + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'dsz': \n if len(ins.args) == 1:\n ins.args[0] = str(ins.args[0]) \n g = re.match(Creg, ins.args[0])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[0]] \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 's.s': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]]\n self.need = [ins.args[0]] + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 's.d': \n if len(ins.args) == 2:\n ins.args[1] = str(ins.args[1]) \n g = re.match(Creg, ins.args[1])\n if g:\n self.c = g.group(1)\n self.need = [Register(g.group(2))]\n else:\n self.need = [ins.args[1]] \n self.need = self.double_reg(ins.args[0]) + self.need \n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'move':\n if len(ins.args) == 2:\n self.need = [ins.args[1]]\n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mov.d':\n if len(ins.args) == 2:\n self.need = self.double_reg(ins.args[1])\n self.gen = self.double_reg(ins.args[0])\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'mov.s':\n if len(ins.args) == 2:\n self.need = [ins.args[1]]\n self.gen = [ins.args[0]]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr) \n \n elif ins.instr == 'li':\n if len(ins.args) == 2:\n self.gen = [ins.args[0]]\n self.ival = ins.args[1]\n else:\n raise Exception(\"Invalid number of args for ins: \", ins.instr)","def handle(args):\n if args.list_targets:\n handle_list_targets(args)\n else:\n if hasattr(args, \"flow_func\"):\n args.flow_func(args)\n else:\n print(\"Invalid command. Check 'mlonmcu flow --help' for the available subcommands!\")\n sys.exit(1)","def cmd(self):","def mlbrumors(self, irc, msg, args):\n\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL3J1bW9ycz93amI9')\n\n try:\n req = urllib2.Request(url)\n html = (urllib2.urlopen(req)).read()\n except:\n irc.reply(\"Something broke trying to read: %s\" % url)\n return\n \n html = html.replace('<div class=\"ind alt\">', '<div class=\"ind\">') \n\n soup = BeautifulSoup(html)\n t1 = soup.findAll('div', attrs={'class': 'ind'})\n\n if len(t1) < 1:\n irc.reply(\"No mlb rumors found. Check formatting?\")\n return\n for t1rumor in t1[0:7]:\n item = t1rumor.find('div', attrs={'class': 'noborder bold tL'}).renderContents()\n item = re.sub('<[^<]+?>', '', item)\n rumor = t1rumor.find('div', attrs={'class': 'inline rumorContent'}).renderContents().replace('\\r','')\n irc.reply(ircutils.bold(item) + \" :: \" + rumor)","def managed_network_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"managed_network_name\")"],"string":"[\n \"def mlnet(self, line, cell):\\n line, cell = CsMagics._preprocess_line_cell_maml( # pylint: disable=W0212\\n line, cell)\\n\\n parser = self.get_parser(CsMagics.CS_parser, \\\"CS\\\")\\n args = self.get_args(line, parser)\\n\\n if args is not None:\\n name = args.name\\n dep = CsMagics._linearise_args(args.dep) # pylint: disable=W0212\\n idep = CsMagics._linearise_args(args.idep) # pylint: disable=W0212\\n\\n if args.catch:\\n try:\\n f = mlnet(name, cell, idep, dep)\\n except Exception as e: # pylint: disable=W0703\\n print(str(e).replace('\\\\r', ''))\\n return None\\n else:\\n f = mlnet(name, cell, idep, dep)\\n if self.shell is not None:\\n self.shell.user_ns[name] = f\\n return f\\n return None\",\n \"def cmd_nlst(args):\",\n \"def niw_mmml_mp(args):\\n return niw_mmml(*args)\",\n \"def magic2python(cmd):\\n\\n if cmd.startswith('#@') or cmd.startswith('@'):\\n if cmd[0]=='#':\\n cmd = cmd[1:]\\n # we need to return the proper line end later\\n if cmd[-1] == '\\\\n':\\n endl = '\\\\n'\\n else:\\n endl = ''\\n try:\\n func,args = cmd[1:].split(' ',1)\\n except:\\n func,args = cmd[1:].rstrip(),''\\n args = args.replace('\\\"','\\\\\\\\\\\"').replace(\\\"'\\\",\\\"\\\\\\\\'\\\").rstrip()\\n return '__IP.magic_%s (\\\"%s\\\")%s' % (func,args,endl)\\n else:\\n return cmd\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='MXNet Gluon Semantic Segmentation')\\n # model and dataset\\n parser.add_argument('--model', type=str, default='fcn',\\n help='model name (default: fcn)')\\n parser.add_argument('--model-zoo', type=str, default=None,\\n help='evaluating on model zoo model')\\n parser.add_argument('--pretrained', action=\\\"store_true\\\",\\n help='whether to use pretrained params')\\n parser.add_argument('--backbone', type=str, default='resnet50',\\n help='backbone name (default: resnet50)')\\n parser.add_argument('--dataset', type=str, default='pascal',\\n help='dataset name (default: pascal)')\\n parser.add_argument('--workers', type=int, default=16,\\n metavar='N', help='dataloader threads')\\n parser.add_argument('--base-size', type=int, default=520,\\n help='base image size')\\n parser.add_argument('--crop-size', type=int, default=480,\\n help='crop image size')\\n parser.add_argument('--train-split', type=str, default='train',\\n help='dataset train split (default: train)')\\n # training hyper params\\n parser.add_argument('--aux', action='store_true', default=False,\\n help='Auxiliary loss')\\n parser.add_argument('--aux-weight', type=float, default=0.5,\\n help='auxiliary loss weight')\\n parser.add_argument('--epochs', type=int, default=50, metavar='N',\\n help='number of epochs to train (default: 50)')\\n parser.add_argument('--start_epoch', type=int, default=0,\\n metavar='N', help='start epochs (default:0)')\\n parser.add_argument('--batch-size', type=int, default=16,\\n metavar='N', help='input batch size for \\\\\\n training (default: 16)')\\n parser.add_argument('--test-batch-size', type=int, default=16,\\n metavar='N', help='input batch size for \\\\\\n testing (default: 16)')\\n parser.add_argument('--optimizer', type=str, default='sgd',\\n help='optimizer (default: sgd)')\\n parser.add_argument('--lr', type=float, default=1e-3, metavar='LR',\\n help='learning rate (default: 1e-3)')\\n parser.add_argument('--warmup-epochs', type=int, default=0,\\n help='number of warmup epochs.')\\n parser.add_argument('--momentum', type=float, default=0.9,\\n metavar='M', help='momentum (default: 0.9)')\\n parser.add_argument('--weight-decay', type=float, default=1e-4,\\n metavar='M', help='w-decay (default: 1e-4)')\\n parser.add_argument('--no-wd', action='store_true',\\n help='whether to remove weight decay on bias, \\\\\\n and beta/gamma for batchnorm layers.')\\n parser.add_argument('--mode', type=str, default=None,\\n help='whether to turn on model hybridization')\\n # cuda and distribute\\n parser.add_argument('--no-cuda', action='store_true', default=False,\\n help='disables CUDA training')\\n parser.add_argument('--ngpus', type=int,\\n default=len(mx.test_utils.list_gpus()),\\n help='number of GPUs (default: 4)')\\n parser.add_argument('--kvstore', type=str, default='device',\\n help='kvstore to use for trainer/module.')\\n parser.add_argument('--dtype', type=str, default='float32',\\n help='data type for training. default is float32')\\n # checking point\\n parser.add_argument('--resume', type=str, default=None,\\n help='put the path to resuming file if needed')\\n parser.add_argument('--checkname', type=str, default='default',\\n help='set the checkpoint name')\\n parser.add_argument('--save-dir', type=str, default=None,\\n help='directory of saved models')\\n parser.add_argument('--log-interval', type=int, default=20,\\n help='Number of batches to wait before logging.')\\n parser.add_argument('--logging-file', type=str, default='train.log',\\n help='name of training log file')\\n # evaluation only\\n parser.add_argument('--eval', action='store_true', default=False,\\n help='evaluation only')\\n parser.add_argument('--no-val', action='store_true', default=False,\\n help='skip validation during training')\\n # synchronized Batch Normalization\\n parser.add_argument('--syncbn', action='store_true', default=False,\\n help='using Synchronized Cross-GPU BatchNorm')\\n # the parser\\n args = parser.parse_args()\\n\\n # handle contexts\\n if args.no_cuda:\\n print('Using CPU')\\n args.kvstore = 'local'\\n args.ctx = [mx.cpu(0)]\\n else:\\n print('Number of GPUs:', args.ngpus)\\n assert args.ngpus > 0, 'No GPUs found, please enable --no-cuda for CPU mode.'\\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\\n\\n if 'psp' in args.model or 'deeplab' in args.model:\\n assert args.crop_size % 8 == 0, ('For PSPNet and DeepLabV3 model families, '\\n 'we only support input crop size as multiples of 8.')\\n\\n # logging and checkpoint saving\\n if args.save_dir is None:\\n args.save_dir = \\\"runs/%s/%s/%s/\\\" % (args.dataset, args.model, args.backbone)\\n makedirs(args.save_dir)\\n\\n # Synchronized BatchNorm\\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\\\\n else mx.gluon.nn.BatchNorm\\n args.norm_kwargs = {'num_devices': args.ngpus} if args.syncbn else {}\\n return args\",\n \"def net_cmd(self):\\n \\n logging.debug(\\\"net_cmd called\\\")\\n cmd = \\\"\\\"\\n # FIXME should probably grab the PrefixLength from the network definition\\n # calc my router\\n \\n # FIXME: Need to split this into separate files...\\n # files will be a dictionary of {\\\"filename\\\":\\\"contents\\\"}\\n files = {}\\n \\n cmd = \\\"rem cmd\\\\r\\\\n\\\"\\n tmpl = \\\"\\\"\\\"netsh interface ip set address \\\"%(nic)s\\\" static %(v4_fixed_ip)s 255.255.255.0\\\\r\\\\n\\\"\\\"\\\"\\n # FIXME: this should be read out of the configuration, probably\\n nets = self.networks\\n ips = self.ip_addresses \\n my_router = \\\"\\\"\\n for netname in nets:\\n v4_fixed_ip = ips.get(netname)\\n my_net = v4_fixed_ip.split(\\\".\\\")[:3]\\n my_net.append(\\\"254\\\")\\n my_router = \\\".\\\".join(my_net)\\n nic = \\\"%s-%s\\\" % (self.footprint.footprint_name, netname)\\n logging.debug(\\\"Creating %s for %s\\\" % (nic, nets))\\n # net_id = self.networks.get(netname)\\n cmd = cmd + tmpl % locals()\\n \\n cmd += \\\"\\\"\\\"route -p add 192.168.1.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n cmd += \\\"\\\"\\\"route -p add 192.168.2.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n cmd += \\\"\\\"\\\"route -p add 192.168.3.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n logging.debug(\\\"cmdfile:\\\\n\\\" + cmd)\\n \\n # print 50 * \\\"x\\\"\\n # print cmd\\n return cmd\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='MXNet Gluon Segmentation')\\n\\n parser.add_argument('--model', type=str, default='fcn', help='model name (default: fcn)')\\n parser.add_argument('--backbone', type=str, default='resnet50', help='backbone name (default: resnet50)')\\n parser.add_argument('--dataset', type=str, default='pascalaug', help='dataset name (default: pascal)')\\n parser.add_argument('--dataset-dir', type=str, default='../imgclsmob_data/voc', help='dataset path')\\n parser.add_argument('--workers', type=int, default=16, metavar='N', help='dataloader threads')\\n parser.add_argument('--base-size', type=int, default=520, help='base image size')\\n parser.add_argument('--crop-size', type=int, default=480, help='crop image size')\\n\\n parser.add_argument('--batch-size', type=int, default=1, metavar='N', help='input batch size for testing')\\n\\n parser.add_argument('--ngpus', type=int, default=len(mx.test_utils.list_gpus()), help='number of GPUs (default: 4)')\\n\\n # checking point\\n parser.add_argument('--resume', type=str, default=None, help='put the path to resuming file if needed')\\n parser.add_argument('--checkname', type=str, default='default', help='set the checkpoint name')\\n parser.add_argument('--model-zoo', type=str, default=None, help='evaluating on model zoo model')\\n\\n # the parser\\n args = parser.parse_args()\\n # handle contexts\\n if args.ngpus == 0:\\n args.ctx = [mx.cpu(0)]\\n else:\\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\\n args.test_batch_size = args.ngpus if args.ngpus > 0 else 1\\n print(args)\\n return args\",\n \"def test_shortopt(self):\\n pp = ParlaiParser(False, False)\\n pp.add_argument(\\\"-m\\\", \\\"--model\\\")\\n pp.add_argument(\\\"-mtw\\\", \\\"--multitask-weights\\\")\\n opt = pp.parse_args([\\\"-m\\\", \\\"memnn\\\"])\\n print(opt)\",\n \"def cmd_mt_irc(word, word_eol, userdata):\\n\\tif len(word) > 1:\\n\\t\\tsubcmd = word[1]\\n\\t\\tif subcmd in subcommands:\\n\\t\\t\\tsubcmd = subcommands[subcmd]\\n\\t\\t\\tsubcmd(word[1:], word_eol[1:])\\n\\t\\telse:\\n\\t\\t\\tprint('[mt_irc] Unknown subcommand \\\"%s\\\". Try \\\"/mt_irc help\\\".')\\n\\telse:\\n\\t\\tprint('Usage: /mt_irc SUBCOMMAND')\\n\\t\\tprint('Try \\\"/mt_irc help\\\".')\\n\\treturn xchat.EAT_XCHAT\",\n \"def _parse_network_list(self, *cmd):\\n if self._fail_network_list:\\n raise processutils.ProcessExecutionError(exit_code=1)\\n else:\\n return NETWORK_LIST, ''\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='MXNet Gluon Segmentation')\\n parser.add_argument('--host', type=str, default='xxx',\\n help='xxx is a place holder')\\n parser.add_argument('--model', type=str, default='ResFPN',\\n help='model name: ResNetFPN, ResUNet')\\n parser.add_argument('--fuse-mode', type=str, default='AsymBi',\\n help='DirectAdd, Concat, SK, BiLocal, BiGlobal, AsymBi, '\\n 'TopDownGlobal, TopDownLocal')\\n parser.add_argument('--tiny', action='store_true', default=False,\\n help='evaluation only')\\n parser.add_argument('--blocks', type=int, default=3,\\n help='block num in each stage')\\n parser.add_argument('--channel-times', type=int, default=1,\\n help='times of channel width')\\n parser.add_argument('--dataset', type=str, default='DENTIST',\\n help='dataset name: DENTIST, Iceberg, StopSign')\\n parser.add_argument('--workers', type=int, default=48,\\n metavar='N', help='dataloader threads')\\n parser.add_argument('--base-size', type=int, default=512,\\n help='base image size')\\n parser.add_argument('--iou-thresh', type=float, default=0.5,\\n help='iou-thresh')\\n parser.add_argument('--crop-size', type=int, default=480,\\n help='crop image size')\\n parser.add_argument('--train-split', type=str, default='trainval',\\n help='dataset train split (default: train)')\\n parser.add_argument('--val-split', type=str, default='test',\\n help='dataset val split (default: val)')\\n # training hyper params\\n parser.add_argument('--epochs', type=int, default=300, metavar='N',\\n help='number of epochs to train (default: 110)')\\n parser.add_argument('--start_epoch', type=int, default=0,\\n metavar='N', help='start epochs (default:0)')\\n parser.add_argument('--batch-size', type=int, default=8,\\n metavar='N', help='input batch size for \\\\\\n training (default: 16)')\\n parser.add_argument('--test-batch-size', type=int, default=8,\\n metavar='N', help='input batch size for \\\\\\n testing (default: 32)')\\n parser.add_argument('--optimizer', type=str, default='adagrad',\\n help='sgd, adam, adagrad')\\n parser.add_argument('--lr', type=float, default=0.05, metavar='LR',\\n help='learning rate (default: 0.1)')\\n parser.add_argument('--lr-decay', type=float, default=0.1,\\n help='decay rate of learning rate. default is 0.1.')\\n parser.add_argument('--gamma', type=int, default=2,\\n help='gamma for Focal Soft IoU Loss')\\n parser.add_argument('--momentum', type=float, default=0.9,\\n metavar='M', help='momentum (default: 0.9)')\\n parser.add_argument('--weight-decay', type=float, default=1e-4,\\n metavar='M', help='w-decay (default: 1e-4)')\\n parser.add_argument('--no-wd', action='store_true',\\n help='whether to remove weight decay on bias, \\\\\\n and beta/gamma for batchnorm layers.')\\n parser.add_argument('--score-thresh', type=float, default=0.5,\\n help='score-thresh')\\n parser.add_argument('--warmup-epochs', type=int, default=0,\\n help='number of warmup epochs.')\\n # cuda and logging\\n parser.add_argument('--no-cuda', action='store_true', default=\\n False, help='disables CUDA training')\\n parser.add_argument('--gpus', type=str, default='0',\\n help='Training with GPUs, you can specify 1,3 for example.')\\n parser.add_argument('--kvstore', type=str, default='device',\\n help='kvstore to use for trainer/module.')\\n parser.add_argument('--dtype', type=str, default='float32',\\n help='data type for training. default is float32')\\n parser.add_argument('--wd', type=float, default=0.0001,\\n help='weight decay rate. default is 0.0001.')\\n parser.add_argument('--log-interval', type=int, default=50,\\n help='Number of batches to wait before logging.')\\n # checking point\\n parser.add_argument('--resume', type=str, default=None,\\n help='put the path to resuming file if needed')\\n parser.add_argument('--colab', action='store_true', default=\\n False, help='whether using colab')\\n parser.add_argument('--save-dir', type=str, default=None,\\n help='directory of saved models')\\n # evaluation only\\n parser.add_argument('--eval', action='store_true', default= False,\\n help='evaluation only')\\n parser.add_argument('--no-val', action='store_true', default= False,\\n help='skip validation during training')\\n parser.add_argument('--metric', type=str, default='mAP',\\n help='F1, IoU, mAP')\\n parser.add_argument('--logging-file', type=str, default='train.log',\\n help='name of training log file')\\n parser.add_argument('--summary', action='store_true',\\n help='print parameters')\\n # synchronized Batch Normalization\\n parser.add_argument('--syncbn', action='store_true', default= False,\\n help='using Synchronized Cross-GPU BatchNorm')\\n # the parser\\n args = parser.parse_args()\\n # handle contexts\\n if args.no_cuda or (len(mx.test_utils.list_gpus()) == 0):\\n print('Using CPU')\\n args.kvstore = 'local'\\n args.ctx = [mx.cpu(0)]\\n else:\\n args.ctx = [mx.gpu(int(i)) for i in args.gpus.split(',') if i.strip()]\\n print('Number of GPUs:', len(args.ctx))\\n\\n # logging and checkpoint saving\\n if args.save_dir is None:\\n args.save_dir = \\\"runs/%s/%s/\\\" % (args.dataset, args.model)\\n makedirs(args.save_dir)\\n\\n # Synchronized BatchNorm\\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\\\\n else mx.gluon.nn.BatchNorm\\n args.norm_kwargs = {'num_devices': len(args.ctx)} if args.syncbn else {}\\n print(args)\\n return args\",\n \"def _parse_ml(self, line):\\n # Parse the line\\n fields = line.split('\\\\\\\\')\\n if self.lang == ENGLISH:\\n # pylint: disable=C0301\\n # English sample:\\n # 14\\\\abandonment\\\\94\\\\C\\\\\\\\1\\\\N\\\\N\\\\N\\\\N\\\\Y\\\\abandon+ment\\\\2x\\\\SA\\\\N\\\\N\\\\N\\\\#\\\\N\\\\N\\\\SA\\\\((abandon)[V],(ment)[N|V.])[N]\\\\N\\\\N\\\\N\\n # From the README:\\n # The eml.cd file contains the following fields:\\n # 1. IdNum\\n # 2. Head\\n # 3. Cob\\n # 4. MorphStatus\\n # 5. Lang\\n # 6. MorphCnt\\n # 7. NVAffComp\\n # 8. Der\\n # 9. Comp\\n # 10. DerComp\\n # 11. Def\\n # 12. Imm\\n # 13. ImmSubCat\\n # 14. ImmSA\\n # 15. ImmAllo\\n # 16. ImmSubst\\n # 17. ImmOpac\\n # 18. TransDer\\n # 19. ImmInfix\\n # 20. ImmRevers\\n # 21 FlatSA\\n # 22. StrucLab\\n # 23. StrucAllo\\n # 24. StrucSubst\\n # 25. StrucOpac\\n lemma = fields[0]\\n word = fields[1]\\n derivation = fields[21]\\n elif self.lang == DUTCH:\\n # pylint: disable=C0301\\n # Dutch sample:\\n # 19\\\\aalbessengelei\\\\7\\\\C\\\\1\\\\Y\\\\Y\\\\Y\\\\aalbes+en+gelei\\\\NxN\\\\N\\\\N\\\\(((aal)[N],(bes)[N])[N],(en)[N|N.N],(gelei)[N])[N]\\\\N\\\\N\\\\N\\n # The dml.cd file contains the following fields:\\n # 1. IdNum\\n # 2. Head\\n # 3. Inl\\n # 4. MorphStatus\\n # 5. MorphCnt\\n # 6. DerComp\\n # 7. Comp\\n # 8. Def\\n # 9. Imm\\n # 10. ImmSubCat\\n # 11. ImmAllo\\n # 12. ImmSubst\\n # 13. StrucLab\\n # 14. StruAcAllo\\n # 15. StrucSubst\\n # 16. Sepa\\n lemma = fields[0]\\n word = fields[1]\\n derivation = fields[12]\\n\\n # Skip multi-word entries for roots\\n roots = self._get_root(derivation) if \\\" \\\" not in word else None\\n return (lemma, word, roots)\",\n \"def maml_parser():\\n parser = MagicCommandParser(prog=\\\"maml\\\",\\n description='Runs a maml script.')\\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\\n help='hide output')\\n return parser\",\n \"def command(self,cmd):\\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))\",\n \"def _make_matlab_command(self):\\n \\n raise NotImplementedError\",\n \"def brain(msg):\\n\\n def check_message(msg):\\n \\\"\\\"\\\"\\n Check wich neuron to use.\\n :param msg:\\n :return:\\n \\\"\\\"\\\"\\n words_of_message = msg.split()\\n find = False\\n for key in gc_words:\\n if words_of_message in gc_words[key]['groups']:\\n getattr(neuron.general_conversations, key)()\\n find = True\\n break\\n for key in fc_words:\\n if words_of_message in fc_words[key]['groups']:\\n getattr(neuron.forecast, key)()\\n find = True\\n break\\n for key in twitter_words:\\n if words_of_message in twitter_words[key]['groups']:\\n getattr(neuron.twitter, key)()\\n find = True\\n break\\n for key in pipo_words:\\n if words_of_message in pipo_words[key]['groups']:\\n getattr(neuron.pipotron, key)()\\n find = True\\n break\\n if not find:\\n neuron.general_conversations.undefined()\\n\\n check_message(msg)\",\n \"def main_net_args(parser, allowed_nets=['fc'], dfc_arch='100,100',\\n dmlp_arch='100,100', show_net_act=True, dnet_act='relu',\\n show_no_bias=False, show_dropout_rate=True,\\n ddropout_rate=-1, show_specnorm=True, show_batchnorm=True,\\n show_no_batchnorm=False, show_bn_no_running_stats=False,\\n show_bn_distill_stats=False,\\n show_bn_no_stats_checkpointing=False,\\n prefix=None, pf_name=None):\\n assert(prefix is None or pf_name is not None)\\n\\n # TODO Delete 'fc' from list.\\n for nt in allowed_nets:\\n assert(nt in ['fc', 'mlp', 'resnet', 'zenke', 'bio_conv_net'])\\n\\n assert(not show_batchnorm or not show_no_batchnorm)\\n\\n # TODO 'fc' should be renamed to 'mlp'.\\n if 'fc' in allowed_nets and len(allowed_nets) == 1:\\n warn('Network type \\\"fc\\\" is deprecated. Default value of argument ' +\\n '\\\"allowed_nets\\\" will be changed to [\\\\'mlp\\\\'] in the future!',\\n DeprecationWarning)\\n elif 'fc' in allowed_nets:\\n # TODO change warning into error at some point.\\n warn('Network type \\\"fc\\\" is deprecated! Use \\\"mlp\\\" instead.',\\n DeprecationWarning)\\n if 'fc' in allowed_nets and 'mlp' in allowed_nets:\\n # Doesn't make sense to have both.\\n raise ValueError('Network type names \\\"fc\\\" and \\\"mlp\\\" refer to the ' +\\n 'same network type! Note, \\\"fc\\\" is deprecated.')\\n\\n heading = 'Main network options'\\n\\n if prefix is None:\\n prefix = ''\\n pf_name = ''\\n else:\\n heading = 'Main network options for %s network' % pf_name\\n pf_name += ' '\\n\\n # Abbreviations.\\n p = prefix\\n n = pf_name\\n\\n ### Main network options.\\n agroup = parser.add_argument_group(heading)\\n\\n if len(allowed_nets) > 1:\\n agroup.add_argument('--%snet_type' % p, type=str,\\n default=allowed_nets[0],\\n help='Type of network to be used for this %s ' % n +\\n 'network. Default: %(default)s.',\\n choices=allowed_nets)\\n\\n # DELETEME once we delete option 'fc'.\\n if 'fc' in allowed_nets:\\n agroup.add_argument('--%sfc_arch' % p, type=str, default=dfc_arch,\\n help='If using a \\\"fc\\\" %s network, this will ' % n +\\n 'specify the hidden layers. ' +\\n 'Default: %(default)s.')\\n\\n if 'mlp' in allowed_nets:\\n agroup.add_argument('--%smlp_arch' % p, type=str, default=dmlp_arch,\\n help='If using a \\\"mlp\\\" %s network, this will ' % n +\\n 'specify the hidden layers. ' +\\n 'Default: %(default)s.')\\n\\n # Note, if you want to add more activation function choices here, you have\\n # to add them to the corresponding function `utils.misc.str_to_act` as well!\\n if show_net_act:\\n agroup.add_argument('--%snet_act' % p, type=str, default=dnet_act,\\n help='Activation function used in the %s network.' % n +\\n 'If \\\"linear\\\", no activation function is used. ' +\\n 'Default: %(default)s.',\\n choices=['linear', 'sigmoid', 'relu', 'elu'])\\n\\n if show_no_bias:\\n agroup.add_argument('--%sno_bias' % p, action='store_true',\\n help='No biases will be used in the %s network. ' % n +\\n 'Note, does not affect normalization (like ' +\\n 'batchnorm).')\\n\\n if show_dropout_rate:\\n agroup.add_argument('--%sdropout_rate' % p, type=float,\\n default=ddropout_rate,\\n help='Use dropout in the %s network with the ' % n +\\n 'given dropout probability (dropout is ' +\\n 'deactivated for a rate of -1). Default: ' +\\n '%(default)s.')\\n\\n if show_specnorm:\\n agroup.add_argument('--%sspecnorm' % p, action='store_true',\\n help='Enable spectral normalization in the ' +\\n '%s network.' % n)\\n\\n ### Batchnorm related options.\\n if show_batchnorm:\\n agroup.add_argument('--%sbatchnorm' % p, action='store_true',\\n help='Enable batchnorm in the %s network.' % n)\\n if show_no_batchnorm:\\n agroup.add_argument('--%sno_batchnorm' % p, action='store_true',\\n help='Disable batchnorm in the %s network.' % n)\\n\\n if show_bn_no_running_stats:\\n agroup.add_argument('--%sbn_no_running_stats' % p, action='store_true',\\n help='If batch normalization is used, then this ' +\\n 'option will deactivate the tracking ' +\\n 'of running statistics. Hence, statistics ' +\\n 'computed per batch will be used during ' +\\n 'evaluation.')\\n\\n if show_bn_distill_stats:\\n agroup.add_argument('--%sbn_distill_stats' % p, action='store_true',\\n help='If batch normalization is used, ' +\\n 'then usually the running statistics are ' +\\n 'checkpointed for every task (e.g., in ' +\\n 'continual learning), which has linearly ' +\\n 'increasing memory requirements. If ' +\\n 'this option is activated, the running ' +\\n 'statistics will be distilled into the ' +\\n 'hypernetwork after training each task, ' +\\n 'such that only the statistics of the ' +\\n 'current and previous task have to be ' +\\n 'explicitly kept in memory')\\n\\n if show_bn_no_stats_checkpointing:\\n agroup.add_argument('--%sbn_no_stats_checkpointing' % p,\\n action='store_true',\\n help='If batch normalization is used, then' +\\n 'this option will prevent the checkpointing' +\\n 'of batchnorm statistics for every task.' +\\n 'In this case, one set of statistics is ' +\\n 'used for all tasks.')\\n\\n return agroup\",\n \"async def man(self, ctx: Context, *, command: str) -> None:\\n base_query = f\\\"https://www.mankier.com/api/v2/mans/?q={command}\\\"\\n query_url = urllib.parse.quote_plus(base_query, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n async with ctx.typing():\\n # Get API query responses\\n async with self.session.get(query_url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n results = json.loads(await response.text())[\\\"results\\\"]\\n\\n # Use first result\\n if len(results) > 0:\\n result = results[0]\\n else:\\n await ctx.send(\\\"Invalid query, no such command\\\")\\n return\\n\\n base_url = f\\\"https://www.mankier.com/api/v2/mans/{result['name']}.{result['section']}\\\"\\n url = urllib.parse.quote_plus(base_url, safe=\\\";/?:@&=$,><-[]\\\")\\n\\n # Load man page from first result\\n async with self.session.get(url) as response:\\n if response.status != 200:\\n await ctx.send(f\\\"An error occurred (status code: {response.status})\\\")\\n return\\n\\n result = json.loads(await response.text())\\n\\n embed = Embed(\\n title=f\\\"Man page of: **{result['name'].capitalize()}**\\\",\\n url=result[\\\"url\\\"],\\n description=f\\\"**{result['description']}** ({result['section']})\\\"\\n )\\n\\n for anchor in result['anchors']:\\n embed.add_field(\\n name=f\\\"`{bleach.clean(anchor['anchor'], tags=[], strip=True)}`\\\",\\n value=f\\\"{bleach.clean(anchor['description'], tags=[], strip=True)}\\\\n[Link here]({anchor['url']})\\\",\\n inline=False\\n )\\n # TODO: Solve this with pagination\\n try:\\n await ctx.send(embed=embed)\\n except HTTPException as e:\\n if e.code == 50035:\\n await ctx.send(embed=Embed(\\n description=\\\"Body is too long to show\\\",\\n color=Color.red()\\n ))\\n else:\\n raise e\",\n \"def resnet110m(**kwargs):\\r\\n return ResNet(BasicBlock, 110, mask=True, **kwargs)\",\n \"def export_mlp(self):\\n return self.net\",\n \"def magic_ll(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^l')\",\n \"def parse():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('--dataset', default='ml-1m', help='which dataset to use')\\n args = parser.parse_args()\\n main(args)\",\n \"def test_lspci_nnmmv_ubuntu_20_10(self):\\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_nnmmv'], quiet=True),\\n self.f_json['ubuntu_20_10_lspci_nnmmv'])\",\n \"def command(self, cmd):\\n self.lmp.command(cmd)\",\n \"def get_net(self,netname, mol = False):\\n lines = self.mfp.get_net(netname)\\n return lines\",\n \"def label(cmd):\\r\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\r\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\r\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\r\\n return cmd\",\n \"def _mnasnet(arch, block, layers, expansions, kernel_sizes, SE, dropout=0,\\n pretrained=False, progress=False, **kwargs):\\n model = MnasNet(block, layers=layers, expansions=expansions, kernel_sizes=kernel_sizes,\\n SE=SE, dropout=dropout, **kwargs)\\n if pretrained:\\n if arch in model_urls.keys():\\n state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)\\n model.load_state_dict(state_dict)\\n return model\",\n \"def netz(self, mask, target, args):\\n print('{mask} netz {args}'.format(mask=mask, args=args))\\n nick = args['<nick>']\\n if nick is None:\\n nick = mask.nick\\n yield self.bot.db.get(nick, {}).get('netz', None) or 'Nichts bekannt über {nick}'.format(nick=nick)\",\n \"def maml(self, line, cell):\\n parser = self.get_parser(CsMLMagics.maml_parser, \\\"maml\\\")\\n args = self.get_args(line, parser)\\n\\n if args is not None:\\n quiet = args.quiet\\n out, err = maml(cell, not quiet)\\n if out:\\n print(out)\\n if err:\\n print('-----')\\n print(err)\",\n \"def get_cmd():\\n parser = argparse.ArgumentParser()\\n parser.add_argument(\\\"-i\\\", action=\\\"store\\\", dest=\\\"inputfile\\\", help=\\\"file with multiple hmm models\\\")\\n parser.add_argument(\\\"-o\\\", action=\\\"store\\\", dest=\\\"dirout\\\", help=\\\"directory to store separated hmm models\\\")\\n params = parser.parse_args()\\n return params\",\n \"def label(cmd):\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\n return cmd\",\n \"def _magic_n(self, args):\\n if idapy._d is None:\\n print \\\"Please select a dump first. Example:\\\"\\n print \\\"sel t2i\\\"\\n return\\n args = args.split(\\\" \\\")\\n s,n = string.join(args[:-1], \\\" \\\"), args[-1]\\n \\n a = addr_from_magic_string(s, rounded_32bit = False)\\n print \\\"NSTUB( 0x%X, %s )\\\" % (a, n)\\n idapy._d.MakeName(a, n)\",\n \"def _llm_type(self) -> str:\\n return \\\"openai\\\"\",\n \"def parse_misc(self,ins):\\n if ins.instr == 'nop':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'syscall':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'break':\\n if len(ins.args) != 0:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n elif ins.instr == 'mflo': \\n if len(ins.args) == 1:\\n self.gen = [ins.args[0]]\\n self.need = [Register(\\\"$lo\\\")]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mtlo': \\n if len(ins.args) == 1:\\n self.gen = [Register(\\\"$lo\\\")]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mfhi': \\n if len(ins.args) == 1:\\n self.gen = [ins.args[0]]\\n self.need = [Register(\\\"$hi\\\")]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mthi': \\n if len(ins.args) == 1:\\n self.gen = [Register(\\\"$hi\\\")]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'mtc1': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[1]]\\n self.need = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mfc1': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.need = [ins.args[1]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'la': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.ival = ins.args[1]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'lui': \\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.ival = ins.args[1]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\",\n \"def _command(f, wrapper, syntax, namespace, internal=False):\\n logger.info('command : syntax : {0}'.format(syntax))\\n node = Tree.fnode(f, wrapper)\\n node.command.syntax = syntax\\n node.command.internal = internal\\n if namespace:\\n Tree().rename_node(node.name, '{0}.{1}'.format(namespace, f.__qualname__))\\n node.command.build_command_parsing_tree()\",\n \"def _llm_type(self) -> str:\\n return \\\"llama.cpp\\\"\",\n \"def __init__(self, entityTypes, tokenClassifier):\\n Finder.__init__(self, entityTypes)\\n self.tokenClassifier = tokenClassifier\\n if self.tokenClassifier != None:\\n self.finderType = 'mention.'+self.tokenClassifier.classifierType\\n else:\\n self.finderType = 'mention'\",\n \"def autosuggest_ml(self, suggest, focus=None, clip=None, display='full',\\n format='json', lang=None):\\n\\n params = {\\n 'addr': suggest,\\n 'display': display,\\n 'format': format,\\n 'lang': lang or self.lang,\\n }\\n if focus:\\n params.update({\\n 'focus': focus\\n })\\n if clip:\\n params.update({\\n 'clip': clip\\n })\\n\\n return self._request('/autosuggest-ml', params)\",\n \"def cmd_mdtm(args):\",\n \"def ReadNet(model_def):\\n with open(model_def) as f:\\n net = cp.NetParameter()\\n pb.text_format.Parse(f.read(), net)\\n return net\",\n \"def meinnetz(self, mask, target, args):\\n print('{mask} meinnetz {args}'.format(mask=mask, args=args))\\n netz = args['<netz>'] or None\\n if netz is not None:\\n netz = ' '.join(netz)\\n self.bot.db.set(mask.nick, netz=netz)\\n yield 'ack'\",\n \"def _from_command_line():\\n # Manim can be called from the command line in three different\\n # ways. The first two involve using the manim or manimcm commands\\n prog = os.path.split(sys.argv[0])[-1]\\n from_cli_command = prog in [\\\"manim\\\", \\\"manimcm\\\"]\\n\\n # The third way involves using `python -m manim ...`. In this\\n # case, the CLI arguments passed to manim do not include 'manim',\\n # 'manimcm', or even 'python'. However, the -m flag will always\\n # be the first argument.\\n from_python_m = sys.argv[0] == \\\"-m\\\"\\n\\n return from_cli_command or from_python_m\",\n \"def but_load_net(self):\\n a = tk.filedialog.askopenfilename(filetypes = [('NN file',['*.csv','*.pt'])])\\n self.nn_obj=load_nn(a)\",\n \"def interpret_nl(nl_string):\\n if nl_string == 'relu':\\n return tf.nn.relu\\n elif nl_string == 'sigmoid':\\n return tf.sigmoid\\n elif nl_string == 'tanh':\\n return tf.tanh\\n else:\\n raise NotImplementedError(nl_string)\",\n \"def mobilenetv1(**kwargs):\\n return MobileNet(**kwargs)\",\n \"def parseargs(p):\\n p.set_defaults(func=func)\\n p.description = \\\"Print machine architecture.\\\"\\n return p\",\n \"def get_command(self, kword: str):\\n # Step Zero is to make sure that the name does not belong to a REAL command.\\n zero, mod = super().get_command(kword)\\n if zero:\\n return zero, mod\\n\\n # Otherwise, first, ensure that the keyword does in fact exist in the custom list.\\n command = self.config.commands.get(kword, None)\\n if not command:\\n return None, None\\n response = command[\\\"com\\\"]\\n\\n # Build the function to return the response. Note that \\\"self\\\" exists already.\\n async def cmd_custom(args, src, **_):\\n if args:\\n member = self.get_member(src, args[0].strip())\\n tag = member.mention if member else None\\n else:\\n tag = None\\n\\n nsfw = command.get(\\\"nsfw\\\", False)\\n if nsfw and src.channel.id not in self.config.get(\\\"nsfwChannels\\\"):\\n return None\\n\\n # Replace tags where needed.\\n try:\\n output = response.format(\\n self=src.author.name,\\n myID=src.author.id,\\n tag=tag or src.author.mention,\\n )\\n except KeyError:\\n return None\\n else:\\n return output\\n\\n # Specify the docstring and name so that !help will work on this.\\n short = response.replace(\\\"{\\\", \\\"{{\\\").replace(\\\"}\\\", \\\"}}\\\")\\n if len(short) > 80:\\n short = short[:77] + \\\"...\\\"\\n cmd_custom.__doc__ = (\\n \\\"__Custom command__: Return the following text: ```{}```\\\\n\\\\n\\\".format(short)\\n + command.get(\\n \\\"desc\\\",\\n \\\"This is a custom command, so available help text is limited, but at the same time, the command is very simple. All it does is return a string, although the string may include formatting tags for invoker name, invoker ID, and a targeted mention.\\\",\\n )\\n + \\\"\\\\n\\\\nSyntax: `{p}\\\"\\n + kword.lower()\\n + (\\\" <user_ID>\\\" if \\\"{tag}\\\" in response else \\\"\\\")\\n + \\\"`\\\"\\n )\\n cmd_custom.__name__ = \\\"cmd_\\\" + kword.lower()\\n\\n return cmd_custom, None\",\n \"def config_megam(bin: Optional[Any] = ...):\\n ...\",\n \"def getArbitraryManInput(self):\\n return \\\"\\\"\\\".TH MANHOLE \\\"1\\\" \\\"August 2001\\\" \\\"\\\" \\\"\\\"\\n.SH NAME\\nmanhole \\\\- Connect to a Twisted Manhole service\\n.SH SYNOPSIS\\n.B manhole\\n.SH DESCRIPTION\\nmanhole is a GTK interface to Twisted Manhole services. You can execute python\\ncode as if at an interactive Python console inside a running Twisted process\\nwith this.\\\"\\\"\\\"\",\n \"def test_findlike():\\n parser = CmdParser([findlike])\\n out = parser.parse(\\\"findlike . -name foo\\\")\\n assert out[0].arguments[0].present == True\\n assert out[0].arguments[0].value == \\\"foo\\\"\\n assert out[0].arguments[1].present == True\\n assert out[0].arguments[1].value == \\\".\\\"\\n assert out[0].as_shell_string() == \\\"findlike . -name foo\\\"\",\n \"def test_set_node_name_for_matmul_add_linear(self, export_args):\\n class Linear(torch.nn.Module):\\n def __init__(self):\\n super(Linear, self).__init__()\\n self.linear = torch.nn.Linear(3, 2)\\n\\n def forward(self, inp):\\n x = self.linear(inp)\\n return x\\n\\n model = Linear()\\n # Using an input to linear op with dimension != 2 causes torch to use matmul->add instead of gemm op\\n onnx_path = './data/MyModel.onnx'\\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 1, 3), onnx_export_args=copy.deepcopy(export_args))\\n onnx_model = onnx.load(onnx_path)\\n expected_node_names = ['linear', 'linear#1.end']\\n\\n actual_node_names = [node.name for node in onnx_model.graph.node]\\n for name in expected_node_names:\\n assert name in actual_node_names\\n\\n expected_param_names = ['linear.weight', 'linear.bias']\\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\\n for name in expected_param_names:\\n assert name in valid_param_set\\n\\n # Check that gemm still works as expected\\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 3), onnx_export_args=copy.deepcopy(export_args))\\n onnx_model = onnx.load(onnx_path)\\n\\n actual_node_names = [node.name for node in onnx_model.graph.node]\\n assert 'linear' in actual_node_names\\n assert 'linear#1' not in actual_node_names\\n\\n expected_param_names = ['linear.weight', 'linear.bias']\\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\\n for name in expected_param_names:\\n assert name in valid_param_set\\n\\n self.check_onnx_node_name_uniqueness(onnx_model)\\n\\n if os.path.exists(onnx_path):\\n os.remove(onnx_path)\",\n \"def __init__(self, node):\\n super(LAMMPSBaseParser, self).__init__(node)\",\n \"def want_label(self, op):\\n return self.want_line(r'\\\\s*\\\\S*(%s)\\\\S*\\\\:.*' % (op))\",\n \"def cmd_type(args):\",\n \"def parsingcommands(self):\\n parser = argparse.ArgumentParser(\\n description=\\\"httpfs is a simple file server.\\\")\\n parser.add_argument(\\\"-v\\\", action=\\\"store_true\\\", dest=\\\"debug\\\",\\n help=\\\"Prints debugging messages.\\\", default=False)\\n parser.add_argument(\\\"-p\\\", action=\\\"store\\\", dest=\\\"port\\\",\\n help=\\\"Specifies the port number that the server will listen and serve at. Default is 8080.\\\",\\n type=int, default=8080)\\n parser.add_argument(\\\"-d\\\", action=\\\"store\\\", dest=\\\"path_to_dir\\\",\\n help=\\\"Specifies the directory that the server will use to read/writerequested files. \\\\\\n Default is the current directory when launching theapplication.\\\",\\n default='./')\\n parser.add_argument(\\\"-arq\\\", action='store_true', dest=\\\"arq\\\", default=False, help=\\\"Automatic-Repeat-Request (ARQ)\\\")\\n\\n return parser.parse_args()\",\n \"def get_default_MXNet_mode():\\n return MXNET_DEFAULT_MODE\",\n \"def parse_args(default_minppmm=1000):\\n parser = argparse.ArgumentParser(formatter_class=argparse.RawTextHelpFormatter)\\n parser.add_argument(\\\"-p\\\", \\\"--plumedir\\\", required=True,\\n help=\\\"path to input plume file directory\\\")\\n parser.add_argument(\\\"-r\\\", \\\"--regex\\\", required=False,\\n default=\\\"ang.*_detections/ime_minppmm{}/ang.*_ime_minppmm{}.*\\\".format(\\n default_minppmm, default_minppmm),\\n help=\\\"Regular expression to match for plume files\\\")\\n parser.add_argument(\\\"-w\\\", \\\"--windir\\\", required=True,\\n help=\\\"path to input wind file directory\\\")\\n parser.add_argument(\\\"-o\\\", \\\"--outfile\\\", required=True,\\n help=\\\"path to output plume list\\\")\\n parser.add_argument(\\\"-f\\\", \\\"--force\\\",\\n help=\\\"Force reprocessing of all files (not just the new ones)\\\",\\n action='store_true')\\n parser.add_argument(\\\"-n\\\", \\\"--nprocs\\\", type=int, default=1,\\n help=\\\"number of parallel processes to use; default=1 (sequential)\\\")\\n parser.add_argument(\\\"--flmode\\\",\\n help=\\\"Executes script in flightline mode, running on a single flightline\\\",\\n action=\\\"store_true\\\")\\n args = parser.parse_args()\\n return (args.plumedir, args.regex, args.windir, args.outfile,\\n args.force, args.nprocs, args.flmode)\",\n \"def parse(self, args):\\r\\n # handle `sl ...`\\r\\n main_args = self.parse_main_args(args)\\r\\n module_name = main_args['<module>']\\r\\n\\r\\n # handle `sl <module> ...`\\r\\n module_args = self.parse_module_args(module_name, main_args['<args>'])\\r\\n\\r\\n # get the command argument\\r\\n command_name = module_args.get('<command>')\\r\\n\\r\\n # handle `sl <module> <command> ...`\\r\\n return self.parse_command_args(\\r\\n module_name,\\r\\n command_name,\\r\\n main_args['<args>'])\",\n \"def do_mdns(self, line):\\n listener = MdnsListener()\\n boards = listener.listen(seconds=1)\\n if len(boards) == 0:\\n print(\\\"No board out there waving it's flag ...\\\")\\n return\\n print(\\\"url ip port spec\\\")\\n for b in boards:\\n print(\\\"{:20s} {:14s} {:2d} {}\\\".format(\\n b.url, b.ip, b.port, b.spec))\",\n \"def lncli(cmd, node_index):\\n node = Node.from_index(node_index)\\n run_lncli(node, cmd)\",\n \"def train_mann_multi(args):\\n\\n src = args.src\\n tgt = args.tgt\\n base_model = args.base_model\\n num_cls = args.num_cls\\n tgt_list = args.tgt_list\\n num_epoch = args.mann_num_epoch\\n batch = args.batch\\n datadir = args.datadir\\n outdir = args.outdir_mann\\n src_weights = args.src_net_file\\n lr = args.mann_lr\\n betas = tuple(args.betas)\\n weight_decay = args.weight_decay\\n centroids_path = args.centroids_src_file\\n feat_dim = 512\\n\\n ###########################\\n # Setup cuda and networks #\\n ###########################\\n\\n # setup cuda\\n if torch.cuda.is_available():\\n kwargs = {'num_workers': 8, 'pin_memory': True}\\n else:\\n kwargs = {}\\n\\n # setup network \\n net = get_model('MannNet', model=base_model, num_cls=num_cls,\\n src_weights_init=src_weights,\\n centroids_path=centroids_path, feat_dim=feat_dim)\\n \\n # print network and arguments\\n print(net)\\n print('Training Mann {} model for {}->{}'.format(base_model, src, tgt))\\n\\n #######################################\\n # Setup data for training and testing #\\n #######################################\\n train_src_data = load_data_multi(src, 'train', batch=batch,\\n rootdir=join(datadir, src), num_channels=net.num_channels,\\n image_size=net.image_size, download=True, kwargs=kwargs)\\n\\n train_tgt_data = load_data_multi(tgt_list, 'train', batch=batch, \\n rootdir=datadir, num_channels=net.num_channels,\\n image_size=net.image_size, download=True, kwargs=kwargs)\\n\\n ######################\\n # Optimization setup #\\n ######################\\n opt_net = optim.Adam(net.tgt_net.parameters(), lr=lr, \\n weight_decay=weight_decay, betas=betas)\\n opt_dis = optim.Adam(net.discriminator.parameters(), lr=lr, \\n weight_decay=weight_decay, betas=betas)\\n opt_selector = optim.Adam(net.fc_selector.parameters(), lr=lr*0.1, \\n weight_decay=weight_decay, betas=betas)\\n opt_classifier = optim.Adam(net.classifier.parameters(), lr=lr*0.1, \\n weight_decay=weight_decay, betas=betas)\\n\\n ##############\\n # Train mann #\\n ##############\\n for epoch in range(num_epoch):\\n err = train_epoch(train_src_data, train_tgt_data, net, opt_net, opt_dis, opt_selector, opt_classifier, epoch) \\n if err == -1:\\n print(\\\"No suitable discriminator\\\")\\n break\\n \\n ##############\\n # Save Model #\\n ##############\\n os.makedirs(outdir, exist_ok=True)\\n outfile = join(outdir, 'mann_{:s}_net_{:s}_{:s}.pth'.format(base_model, src, tgt))\\n print('Saving to', outfile)\\n net.save(outfile)\",\n \"def __init__(self, *args):\\n _snap.TMMNet_swiginit(self, _snap.new_TMMNet(*args))\",\n \"def graph_cmd(args):\\n\\n # charge graphviz\\n Digraph = load_graphviz()\\n\\n view = True\\n for i in args:\\n if i == \\\"noview\\\":\\n view = False\\n args.remove(i)\\n break\\n\\n if len(args) > 0:\\n if len(args) >= 2:\\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \\\"traverse\\\":args[1], \\\"mibs\\\":\\\"base\\\" })\\n else:\\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \\\"mibs\\\":\\\"base\\\" })\\n else:\\n r = requete('NeMo.Intf.lo:getMIBs', { \\\"traverse\\\":\\\"all\\\", \\\"mibs\\\":\\\"base\\\" })\\n if r is None: return\\n if not 'status' in r or not 'base' in r['status']: return\\n r = r['status']['base']\\n\\n dot = Digraph(name='NeMo.Intf', format='svg', engine='dot')\\n\\n dot.attr('node', fontname='Helvetica')\\n #dot.attr('node', fontname='Times-Roman')\\n\\n for i, node in r.items():\\n #dot.attr('node', tooltip=v['Flags'] if 'Flags' in v else '')\\n if 'Enable' in node:\\n if node['Enable'] == True:\\n dot.node(i, shape='box')\\n else:\\n dot.node(i, shape='ellipse', color='lightgrey')\\n else:\\n dot.node(i, shape='box', color='lightgrey')\\n\\n for i, v in r.items():\\n for j in v['LLIntf']:\\n dot.edge(i, j)\\n\\n dot.render(filename=\\\"nemo_intf.gv\\\", view=view)\",\n \"def parse_cmd_args():\\n parser = argparse.ArgumentParser()\\n parser.add_argument('-m', '--path_model', type=str, help='Path to trained model.')\\n parser.add_argument('-t', '--type', type=str, help='Either \\\"torch\\\" or \\\"sklearn\\\".')\\n # parser.add_argument('-l', '--location', type=str, help='Either \\\"local\\\", \\\"midgard\\\" or \\\"rattle\\\"')\\n parser.add_argument('-i', '--path_in', type=str, help='Path to input file.')\\n parser.add_argument('-o', '--path_out', type=str, help='Path to output file.')\\n parser.add_argument('-c', '--path_config', type=str, help='Path to config file.')\\n parser.add_argument('-g', '--gpu', type=int, default=0, help='Number of the gpu to be used.')\\n return parser.parse_args()\",\n \"def parse(self, message, prefix, cmd_list):\\n\\n self.parse_type = \\\"\\\"\\n self.parse_msg = []\\n for i in message:\\n if i[0].isdigit():\\n self.parse_number(i, \\\"w\\\")\\n elif len(i) == 1:\\n self.parse_type += \\\"w\\\"\\n self.parse_msg.append(i)\\n elif i == \\\"@everyone\\\" or i == \\\"@here\\\":\\n self.parse_type += \\\"s\\\"\\n self.parse_msg.append(i)\\n elif i[0] == prefix:\\n self.parse_command(i, cmd_list)\\n elif i[0] == \\\"-\\\":\\n self.parse_number(i, \\\"o\\\")\\n elif i[0] == \\\"<\\\" and len(i) > 3:\\n self.parse_mention(i)\\n else:\\n self.parse_type += \\\"w\\\"\\n self.parse_msg.append(i[(i[0] == \\\"\\\\\\\\\\\"):])\",\n \"def mgcNetArch(self, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : self.input_img_rows,\\n \\\"input_img_cols\\\" : self.input_img_cols,\\n \\\"channels\\\" : self.channels,\\n \\\"nb_classes\\\" : self.nb_classes,\\n \\\"outLayer\\\" : 'gloAvg', \\n \\\"l2_val\\\" : 0.00, \\n \\\"net_architr\\\" : 'cnn_max', \\n \\\"block_typex\\\" : 'basic', \\n \\\"block_repeatx\\\" : [1, 1]\\n }\\n\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n _input_img_rows = kwargs['input_img_rows']\\n _input_img_cols = kwargs['input_img_cols']\\n _channels = kwargs['channels']\\n _nb_classes = kwargs['nb_classes']\\n _outLayer = kwargs['outLayer']\\n _l2_val = kwargs['l2_val']\\n _net_architr = kwargs['net_architr']\\n _block_typex = kwargs['block_typex']\\n _block_repeatx = kwargs['block_repeatx']\\n \\n \\n params = {\\\"input_img_rows\\\" : _input_img_rows,\\n \\\"input_img_cols\\\" : _input_img_cols,\\n \\\"channels\\\" : _channels,\\n \\\"nb_classes\\\" : _nb_classes\\n }\\n \\n print(_net_architr)\\n if _net_architr == 'cnn_max':\\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'cnn_stride':\\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'cnn_stride_mini':\\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'common_cnn':\\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'net_in_net':\\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'resnet':\\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\\n \\n elif _net_architr == 'resblock':\\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'skipconnect':\\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\\n elif _net_architr == 'skipconnect_mini':\\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n self.model = model\\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\\n #self.model_summary = model.summary() \\n \\n return self\",\n \"def cmd(self, cmd):\\n return cmd\",\n \"def mod_command(server, output):\\n for target in output.message.split()[1:]:\\n if target in server.ops:\\n server.tell(output.name, '%s is an operator' % (target))\\n continue\\n if target in server.mods:\\n server.tell(output.name, '%s is already a mod' % (target))\\n else:\\n server.mod(output, target)\\n return\",\n \"def netlogo_args():\\n return {\\n \\\"model\\\": \\\"/home/smitty/proj/css600transp/css600transp/FireSim.nlogo\\\",\\n \\\"setup-file\\\": \\\"setup-file.xml\\\",\\n \\\"experiment\\\": \\\"FireSim\\\",\\n \\\"threads\\\": \\\"1\\\",\\n \\\"table\\\": \\\"-\\\",\\n }\",\n \"def handle_magic(self, line, continue_prompt=None,\\n pre=None,iFun=None,theRest=None):\\n\\n cmd = '%sipmagic(\\\"%s\\\")' % (pre,esc_quotes('%s %s' % (iFun,theRest)))\\n self.log(cmd,continue_prompt)\\n self.update_cache(line)\\n #print 'in handle_magic, cmd=<%s>' % cmd # dbg\\n return cmd\",\n \"def arg_parsing():\\n\\n # parser instance\\n parser = argparse.ArgumentParser(description=\\\"Neural Network Settings\\\")\\n\\n # select data directory\\n parser.add_argument('--data_dir', \\n type=str, \\n help='Data directory.')\\n \\n # select architecture\\n parser.add_argument('--arch', \\n type=str, \\n help='Choose architecture from torchvision.models')\\n \\n # select directory\\n parser.add_argument('--save_dir', \\n type=str, \\n help='Saving directory path for checkpoints.')\\n \\n # set hyperparameters\\n parser.add_argument('--learning_rate', \\n type=float, \\n help='Gradient descent learning rate')\\n parser.add_argument('--hidden_units', \\n type=int, \\n help='Number of hidden layers for DNN.')\\n parser.add_argument('--epochs', \\n type=int, \\n help='Number of epochs for training.')\\n\\n # set gpu option\\n parser.add_argument('--gpu', \\n action=\\\"store_true\\\", \\n help='Use GPU.')\\n \\n # args\\n args = parser.parse_args()\\n \\n return args\",\n \"def build_command(args, parser):\\n cmd = \\\"ipmitool -I lanplus\\\"\\n if not args.host:\\n print \\\"\\\\nERROR: hostname is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -H ' + args.host\\n if args.port:\\n cmd += ' -p ' + args.port\\n if not args.user:\\n print \\\"\\\\nERROR: username is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -U ' + args.user\\n if args.passwd:\\n cmd += ' -P ' + args.passwd\\n cmd += ' dcmi power reading'\\n if args.interval:\\n global INTERVAL\\n INTERVAL = args.interval\\n if args.nread:\\n global NREAD\\n NREAD = args.nread\\n else:\\n global INFINITY\\n INFINITY = True\\n if args.store:\\n global STORE\\n STORE = True\\n return cmd\",\n \"def intf_MMLIST(E):\\n print(MMEL.__repr__())\\n #print(OUT.default(MMEL,E))\",\n \"def parse_cl():\\n import argparse\\n\\n parser = argparse.ArgumentParser(description='')\\n parser.add_argument('--lef', action=\\\"store\\\", dest='src_lef', required=True)\\n parser.add_argument('--def', action=\\\"store\\\", dest='src_def', required=True)\\n parser.add_argument('--verilog', action=\\\"store\\\", dest='src_v', required=True)\\n parser.add_argument('--pl', action=\\\"store\\\", dest='final_pl')\\n parser.add_argument('--def_out', action=\\\"store\\\", dest='dest_def', default='out.def')\\n\\n opt = parser.parse_args()\\n\\n return opt\",\n \"def parse(self, args):\\n pass\",\n \"def magic_lsmagic(self, parameter_s = ''):\\n print 'Available magic functions:\\\\n@'+' @'.join(self.lsmagic())\\n print '\\\\n' + Magic.auto_status[self.rc.automagic]\\n return None\",\n \"def parse(self, commands):\\n raise NotImplementedError()\",\n \"def decomp(net):\\n \\n pt_netname = Word(alphanums) + Suppress('_') + restOfLine\\n pt_netnamebus = Word(alphanums) + Suppress('_') + Word(alphanums+'_') + \\\\\\n Suppress('[') + Word(nums) + Suppress(']')\\n parser = (pt_netnamebus | pt_netname)\\n \\n return parser.parseString(net)\",\n \"def __init__(self, *args):\\n _snap.TMMNetModeNetI_swiginit(self, _snap.new_TMMNetModeNetI(*args))\",\n \"def cmdline(self):\\r\\n raise NotImplementedError\",\n \"def test_lspci_nmmv_ubuntu_20_10(self):\\n self.assertEqual(jc.parsers.lspci.parse(self.f_in['ubuntu_20_10_lspci_nmmv'], quiet=True),\\n self.f_json['ubuntu_20_10_lspci_nmmv'])\",\n \"def _register_commands(self):\\n cmds = []\\n cmd_help = CommandParser(\\\"help\\\", \\\"Show help for a command.\\\")\\n cmd_help.add_argument(\\n \\\"command\\\",\\n nargs=\\\"*\\\",\\n help=\\\"The command to get help for. Specify multiple names to get help for subcommands.\\\",\\n )\\n cmd_help.add_argument(\\\"-m\\\", \\\"--module\\\", help=\\\"List all commands from the given module\\\")\\n cmd_help.add_argument(\\n \\\"-f\\\",\\n \\\"--full\\\",\\n action=\\\"store_true\\\",\\n help='Include descriptions in the \\\"all\\\" help output.',\\n )\\n cmds.append(cmd_help)\\n\\n target_mod = CommandParser()\\n target_mod.add_argument(\\\"module\\\", nargs=\\\"+\\\", help=\\\"Target module(s)\\\")\\n target_mod.add_argument(\\n \\\"-p\\\",\\n \\\"--protocol\\\",\\n action=\\\"store_const\\\",\\n const=\\\"protocol\\\",\\n default=\\\"feature\\\",\\n dest=\\\"mtype\\\",\\n help=\\\"Target is a protocol module\\\",\\n )\\n cmd_module = CommandParser(\\\"module\\\", \\\"Manage and query ZeroBot modules\\\")\\n add_subcmd = cmd_module.make_adder(metavar=\\\"OPERATION\\\", dest=\\\"subcmd\\\", required=True)\\n add_subcmd(\\\"load\\\", description=\\\"Load a module\\\", parents=[target_mod])\\n add_subcmd(\\\"reload\\\", description=\\\"Reload a module\\\", parents=[target_mod])\\n subcmd_list = add_subcmd(\\\"list\\\", description=\\\"List available modules\\\")\\n subcmd_list.add_argument(\\\"-l\\\", \\\"--loaded\\\", action=\\\"store_true\\\", help=\\\"Only loaded modules\\\")\\n list_group = subcmd_list.add_mutually_exclusive_group()\\n default_categories = [\\\"protocol\\\", \\\"feature\\\"]\\n list_group.add_argument(\\n \\\"-f\\\",\\n \\\"--feature\\\",\\n action=\\\"store_const\\\",\\n const=[\\\"feature\\\"],\\n dest=\\\"category\\\",\\n default=default_categories,\\n help=\\\"Only feature modules\\\",\\n )\\n list_group.add_argument(\\n \\\"-p\\\",\\n \\\"--protocol\\\",\\n action=\\\"store_const\\\",\\n const=[\\\"protocol\\\"],\\n dest=\\\"category\\\",\\n default=default_categories,\\n help=\\\"Only protocol modules\\\",\\n )\\n add_subcmd(\\\"info\\\", description=\\\"Show module information\\\", parents=[target_mod])\\n cmds.append(cmd_module)\\n\\n save_reload_args = CommandParser()\\n save_reload_args.add_argument(\\n \\\"config_file\\\",\\n nargs=\\\"*\\\",\\n help=\\\"Name of config file (without .toml extension). Omit to affect all loaded config files.\\\",\\n )\\n set_reset_args = CommandParser()\\n set_reset_args.add_argument(\\\"config_file\\\", help=\\\"Name of config file (without .toml extension)\\\")\\n cmd_config = CommandParser(\\\"config\\\", \\\"Manage configuration\\\")\\n add_subcmd = cmd_config.make_adder(metavar=\\\"OPERATION\\\", dest=\\\"subcmd\\\", required=True)\\n add_subcmd(\\\"save\\\", description=\\\"Save config files to disk\\\", parents=[save_reload_args])\\n subcmd_savenew = add_subcmd(\\\"savenew\\\", description=\\\"Save config file to a new path\\\")\\n subcmd_savenew.add_argument(\\\"config_file\\\", help=\\\"Name of config file (without .toml extension)\\\")\\n subcmd_savenew.add_argument(\\\"new_path\\\", help=\\\"The path to save the config file to\\\")\\n add_subcmd(\\n \\\"reload\\\",\\n description=\\\"Reload config files from disk\\\",\\n parents=[save_reload_args],\\n )\\n subcmd_set = add_subcmd(\\\"set\\\", description=\\\"Modify config settings\\\", parents=[set_reset_args])\\n subcmd_set.add_argument(\\n \\\"key_path\\\",\\n help=\\\"The config key to set. Subkeys are separated by dots, e.g. 'Core.Backup.Filename'\\\",\\n )\\n subcmd_set.add_argument(\\\"value\\\", nargs=\\\"?\\\", help=\\\"The new value. Omit to show the current value.\\\")\\n subcmd_reset = add_subcmd(\\n \\\"reset\\\",\\n description=\\\"Reset config settings to last loaded value\\\",\\n parents=[set_reset_args],\\n )\\n subcmd_reset.add_argument(\\n \\\"key_path\\\",\\n nargs=\\\"?\\\",\\n help=(\\n \\\"The config key to set. Subkeys are separated by dots, \\\"\\n \\\"e.g. 'Core.Backup.Filename'. If omitted, the entire \\\"\\n \\\"config will be reset.\\\"\\n ),\\n )\\n subcmd_reset.add_argument(\\n \\\"-d\\\",\\n \\\"--default\\\",\\n action=\\\"store_true\\\",\\n help=\\\"Set the key to its default value instead. Effectively unsets a config key.\\\",\\n )\\n cmds.append(cmd_config)\\n\\n cmd_version = CommandParser(\\\"version\\\", \\\"Show version information\\\")\\n cmds.append(cmd_version)\\n\\n cmd_restart = CommandParser(\\\"restart\\\", \\\"Restart ZeroBot.\\\")\\n cmd_restart.add_argument(\\\"msg\\\", nargs=\\\"*\\\", help=\\\"Message sent to protocol modules as a reason\\\")\\n cmds.append(cmd_restart)\\n\\n cmd_quit = CommandParser(\\\"quit\\\", \\\"Shut down ZeroBot.\\\")\\n cmd_quit.add_argument(\\\"msg\\\", nargs=\\\"*\\\", help=\\\"Message sent to protocol modules as a reason\\\")\\n cmds.append(cmd_quit)\\n\\n cmd_wait = CommandParser(\\\"wait\\\", \\\"Execute a command after a delay\\\")\\n cmd_wait.add_argument(\\n \\\"delay\\\",\\n help=\\\"Amount of time to delay. Accepts the following modifier suffixes: 'ms', 's' (default), 'm', 'h'.\\\",\\n )\\n cmd_wait.add_argument(\\\"command\\\", help=\\\"Command to delay\\\")\\n cmd_wait.add_argument(\\\"args\\\", nargs=argparse.REMAINDER, help=\\\"Command arguments\\\")\\n cmds.append(cmd_wait)\\n\\n cmd_cancel = CommandParser(\\\"cancel\\\", \\\"Cancel a waiting command\\\")\\n cancel_group = cmd_cancel.add_mutually_exclusive_group()\\n cancel_group.add_argument(\\\"id\\\", type=int, nargs=\\\"?\\\", help=\\\"The ID of a waiting command\\\")\\n cancel_group.add_argument(\\\"-l\\\", \\\"--list\\\", action=\\\"store_true\\\", help=\\\"List currently waiting commands\\\")\\n cmds.append(cmd_cancel)\\n\\n cmd_backup = CommandParser(\\\"backup\\\", \\\"Create a database backup\\\")\\n cmd_backup.add_argument(\\\"name\\\", type=Path, help=\\\"Backup filename\\\")\\n cmds.append(cmd_backup)\\n\\n self.command_register(\\\"core\\\", *cmds)\",\n \"def parse_cmd(cmd):\\n begin_pat = re.compile(r'BEGIN\\\\s*\\\\{(.+?)\\\\}\\\\s*;?', re.X | re.S)\\n end_pat = re.compile(r'END\\\\s*\\\\{(.+?)\\\\}\\\\s*;?', re.X | re.S)\\n normal_pat = re.compile(r'([^{]*)(\\\\{(.+?)\\\\})?\\\\s*;?', re.X | re.S)\\n\\n # get BEGIN part\\n begin = u''\\n m = begin_pat.search(cmd)\\n if m:\\n begin = m.group(1).strip()\\n cmd = cmd.replace(m.group(0), u'')\\n\\n # get END part\\n end = u''\\n m = end_pat.search(cmd)\\n if m:\\n end = m.group(1).strip()\\n cmd = cmd.replace(m.group(0), u'')\\n\\n # get NORMAL part\\n normal = (u'', u'')\\n m = normal_pat.search(cmd)\\n if m:\\n pattern = m.group(1) or u'' # get u'' if \\\\1 is None\\n action = m.group(3) or u'' # get u'' if \\\\3 is None\\n normal = (pattern.strip(), action.strip())\\n\\n return (begin, normal, end)\",\n \"def __init__(self):\\n self.label = \\\"Neural network input files\\\"\\n self.description = \\\"Use this tool to create the input ASCII files for the GeoXplore neural network. Before using this tool, the evidence must be combined into a unique conditions raster with the Combine tool and the band statistics must be obtained for all the evidence using the Band Collection Statistics tool. If desired fuzzy membership attribute can be added to each of the training sites. See the ArcMap Tools Options discussion in Usage Tips in the Help about adjusting default setting for this tool.\\\"\\n self.canRunInBackground = False\\n self.category = \\\"Neural network\\\"\",\n \"def parse_args():\\n parser = common.default_args(net_name=NET_NAME, \\n num_classes=21, image_size=IMAGE_SIZE)\\n parser.add_argument('--trained-model', required=False, help='Path to trained state_dict file', \\n default=TRAINED_MODEL_PATH)\\n return parser.parse_args()\",\n \"def commandParser(self, testtype, command):\\n if testtype == 'command':\\n if type(command) == types.StringType:\\n # Type is a string: it has to be transformed into a list\\n l = command.split(\\\" \\\")\\n pos = 0\\n for i in l:\\n if (i.startswith('%') and i.endswith('%')):\\n # if item contains environment variable (e.g. %nmap%), it is replaced with its value (config.cfg)\\n if(i == \\\"%target%\\\"):\\n l[pos] = self._target\\n elif(self.config.has_option('ENV',i.replace('%',''))):\\n l[pos] = self.config.get('ENV',i.replace('%',''))\\n else:\\n print \\\"\\\"\\\"***ERROR: Environment variable not found in command %s\\\"\\\"\\\" % command\\n sys.exit()\\n pos += 1\\n elif type(command) == types.ListType:\\n # Type is a list: nothing to do\\n l = command\\n else:\\n print \\\"\\\"\\\"***ERROR: Syntax error for command %s\\\"\\\"\\\" % command\\n sys.exit()\\n return l\\n else:\\n envlist = self.config.options('ENV')\\n tmp = command\\n # Replace every eventual reference to an environment variable\\n for envvar in envlist:\\n tmp = tmp.replace(\\\"%\\\"+envvar+\\\"%\\\", self.config.get('ENV', envvar))\\n # Replace %target% keyword\\n tmp = tmp.replace('%target%', self._target)\\n return tmp\",\n \"def __getFullCommandName(self, command, type):\\n return 'cmd_%s_%s' % (type, command)\",\n \"def parse(string: str) -> 'NbfCommand':\\n part_strs = string.split('_')\\n if len(part_strs) != 3:\\n raise NbfParseError(f\\\"nbf command \\\\\\\"{string}\\\\\\\" malformed, should have exactly three parts\\\")\\n\\n opcode_str, addr_str, data_str = part_strs\\n try:\\n opcode = int(opcode_str, 16)\\n addr = reverse_bytes(bytes.fromhex(addr_str))\\n data = reverse_bytes(bytes.fromhex(data_str))\\n except ValueError:\\n raise NbfParseError(f\\\"nbf command \\\\\\\"{string}\\\\\\\" malformed, contains invalid hex bytes\\\")\\n\\n if len(addr) != ADDRESS_LENGTH_BYTES:\\n raise NbfParseError(f\\\"nbf command \\\\\\\"{string}\\\\\\\" malformed, address must be exactly {ADDRESS_LENGTH_BYTES} bytes\\\")\\n\\n if len(data) != DATA_LENGTH_BYTES:\\n raise NbfParseError(f\\\"nbf command \\\\\\\"{string}\\\\\\\" malformed, data must be exactly {DATA_LENGTH_BYTES} bytes\\\")\\n\\n return NbfCommand(opcode, addr, data)\",\n \"def mt_classifier(input_file, muscle_exec, basename, best_results):\\n pass\",\n \"def metaphor_magnet(word):\\r\\n try:\\r\\n link = \\\"http://ngrams.ucd.ie/metaphor-magnet-acl/q?kw=\\\" + word\\r\\n f = urllib.request.urlopen(link)\\r\\n myfile = f.read()\\r\\n myfile = myfile.decode()\\r\\n data = myfile[myfile.index(\\\"data.setCell\\\"):myfile.rindex(\\\"data.setCell\\\")]\\r\\n data = data.split(\\\"data.setCell\\\")\\r\\n choice = 1\\r\\n magnet_list = []\\r\\n while choice < len(data)-1:\\r\\n words = data[choice][data[choice].index(\\\"\\\\\\\"\\\")+1:data[choice].rindex(\\\",\\\")]\\r\\n magnet_list.append(words)\\r\\n choice +=3 \\r\\n \\r\\n return magnet_list\\r\\n # if nothing is found, try again with a different word\\r\\n except ValueError:\\r\\n choice = random.randint(0,len(RAND_LIST)-1)\\r\\n return metaphor_magnet(RAND_LIST[choice])\",\n \"def test_support_NETWORK(self):\\n self.assertEqual(self._parseFeature(\\\"NETWORK\\\", \\\"IRCNet\\\"), \\\"IRCNet\\\")\",\n \"def __getattr__(self, cmd):\\n\\n if hasattr(self._rpc, cmd+'Request'):\\n lnfunc = getattr(self._rpc, cmd+'Request')\\n elif hasattr(self._rpc, f'Get{cmd}Request'):\\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\\n else:\\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\\n\\n if hasattr(self._stub, cmd):\\n stubfunc = getattr(self._stub, cmd)\\n\\n def rpcCommand(*args,**kwargs):\\n return stubfunc(lnfunc(*args, **kwargs))\\n return rpcCommand\\n\\n elif hasattr(self._stub, 'Get'+cmd):\\n stubfunc = getattr(self._stub, 'Get'+cmd)\\n def rpcCommand(*args,**kwargs):\\n if args:\\n raise TypeError('Cannot use positional arguments with this command')\\n return stubfunc(lnfunc(**kwargs))\\n return rpcCommand\\n\\n else:\\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)\",\n \"def network(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"network\\\")\",\n \"def test_rename_to_mlflow(mlflow):\\n atom = ATOMClassifier(X_bin, y_bin, experiment=\\\"test\\\", random_state=1)\\n atom.run(\\\"GNB\\\")\\n atom.scoring()\\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training\",\n \"def ftp_MLST(self, line):\\n # if no argument, fall back on cwd as default\\n if not line:\\n line = self.fs.cwd\\n path = self.fs.ftp2fs(line)\\n line = self.fs.ftpnorm(line)\\n basedir, basename = os.path.split(path)\\n try:\\n data = self.fs.format_mlsx(basedir, [basename], ignore_err=False)\\n except OSError, err:\\n why = _strerror(err)\\n self.log('FAIL MLST \\\"%s\\\". %s.' %(line, why))\\n self.respond('550 %s.' %why)\\n else:\\n # where TVFS is supported, a fully qualified pathname\\n # should be returned\\n data = data.split(' ')[0] + ' %s\\\\r\\\\n'%line\\n # response is expected on the command channel\\n self.push('250-Listing \\\"%s\\\":\\\\r\\\\n' %line)\\n # the fact set must be preceded by a space\\n self.push(' ' + data)\\n self.respond('250 End MLST.')\",\n \"def parse_ls(self,ins):\\n global Creg\\n if ins.instr == 'lb':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1])\\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'lbu':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'lh':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'lhu':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'lw':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n \\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'dlw':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.gen = self.double_reg(ins.args[0])\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'dmfc1':\\n if len(ins.args) == 2:\\n self.need = [ins.args[1]] \\n self.gen = self.double_reg(ins.args[0])\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'l.s':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n \\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'l.d':\\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n \\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'sb': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.need = [ins.args[0]] + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\\n \\n elif ins.instr == 'sbu': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1])\\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.need = [ins.args[0]] + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'sh': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1])\\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.need = [ins.args[0]] + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'shu': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.need = [ins.args[0]] + self.need \\n \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'sw': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.need = [ins.args[0]] + self.need\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'dsw': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.need = self.double_reg(ins.args[0]) + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'dsz': \\n if len(ins.args) == 1:\\n ins.args[0] = str(ins.args[0]) \\n g = re.match(Creg, ins.args[0])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[0]] \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 's.s': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]]\\n self.need = [ins.args[0]] + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 's.d': \\n if len(ins.args) == 2:\\n ins.args[1] = str(ins.args[1]) \\n g = re.match(Creg, ins.args[1])\\n if g:\\n self.c = g.group(1)\\n self.need = [Register(g.group(2))]\\n else:\\n self.need = [ins.args[1]] \\n self.need = self.double_reg(ins.args[0]) + self.need \\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'move':\\n if len(ins.args) == 2:\\n self.need = [ins.args[1]]\\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mov.d':\\n if len(ins.args) == 2:\\n self.need = self.double_reg(ins.args[1])\\n self.gen = self.double_reg(ins.args[0])\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'mov.s':\\n if len(ins.args) == 2:\\n self.need = [ins.args[1]]\\n self.gen = [ins.args[0]]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr) \\n \\n elif ins.instr == 'li':\\n if len(ins.args) == 2:\\n self.gen = [ins.args[0]]\\n self.ival = ins.args[1]\\n else:\\n raise Exception(\\\"Invalid number of args for ins: \\\", ins.instr)\",\n \"def handle(args):\\n if args.list_targets:\\n handle_list_targets(args)\\n else:\\n if hasattr(args, \\\"flow_func\\\"):\\n args.flow_func(args)\\n else:\\n print(\\\"Invalid command. Check 'mlonmcu flow --help' for the available subcommands!\\\")\\n sys.exit(1)\",\n \"def cmd(self):\",\n \"def mlbrumors(self, irc, msg, args):\\n\\n url = self._b64decode('aHR0cDovL20uZXNwbi5nby5jb20vbWxiL3J1bW9ycz93amI9')\\n\\n try:\\n req = urllib2.Request(url)\\n html = (urllib2.urlopen(req)).read()\\n except:\\n irc.reply(\\\"Something broke trying to read: %s\\\" % url)\\n return\\n \\n html = html.replace('<div class=\\\"ind alt\\\">', '<div class=\\\"ind\\\">') \\n\\n soup = BeautifulSoup(html)\\n t1 = soup.findAll('div', attrs={'class': 'ind'})\\n\\n if len(t1) < 1:\\n irc.reply(\\\"No mlb rumors found. Check formatting?\\\")\\n return\\n for t1rumor in t1[0:7]:\\n item = t1rumor.find('div', attrs={'class': 'noborder bold tL'}).renderContents()\\n item = re.sub('<[^<]+?>', '', item)\\n rumor = t1rumor.find('div', attrs={'class': 'inline rumorContent'}).renderContents().replace('\\\\r','')\\n irc.reply(ircutils.bold(item) + \\\" :: \\\" + rumor)\",\n \"def managed_network_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"managed_network_name\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.57447124","0.53171813","0.5278795","0.52074957","0.5104776","0.5055335","0.50357693","0.5034653","0.49979833","0.49518523","0.4937366","0.49060217","0.49001834","0.4745951","0.47331885","0.4656194","0.46342298","0.46050298","0.46031177","0.4588288","0.4587108","0.45867229","0.4583484","0.45825943","0.4566405","0.4548295","0.4545266","0.4538004","0.45378256","0.45352617","0.45263907","0.45255142","0.4504833","0.44985098","0.4496821","0.44963092","0.44941193","0.44938564","0.4477105","0.44717756","0.44591832","0.4457597","0.44477665","0.44275886","0.4422899","0.44005114","0.43947035","0.4383181","0.43617284","0.4357111","0.4348767","0.43408453","0.43338823","0.43234774","0.43216935","0.43183312","0.4316178","0.4316174","0.43120253","0.43100435","0.43059316","0.42963248","0.42945355","0.42942664","0.4283655","0.4282241","0.4272585","0.42696986","0.426662","0.42661366","0.42584962","0.42554128","0.42460766","0.42452443","0.4243876","0.42434978","0.4242356","0.4240616","0.42393553","0.42363828","0.42346913","0.42311624","0.4229035","0.42286488","0.42244828","0.42244604","0.42204863","0.42109975","0.4209665","0.42084795","0.42033747","0.42033142","0.41988605","0.41958228","0.4193592","0.4191341","0.4181615","0.41775793","0.41771618","0.41740996"],"string":"[\n \"0.57447124\",\n \"0.53171813\",\n \"0.5278795\",\n \"0.52074957\",\n \"0.5104776\",\n \"0.5055335\",\n \"0.50357693\",\n \"0.5034653\",\n \"0.49979833\",\n \"0.49518523\",\n \"0.4937366\",\n \"0.49060217\",\n \"0.49001834\",\n \"0.4745951\",\n \"0.47331885\",\n \"0.4656194\",\n \"0.46342298\",\n \"0.46050298\",\n \"0.46031177\",\n \"0.4588288\",\n \"0.4587108\",\n \"0.45867229\",\n \"0.4583484\",\n \"0.45825943\",\n \"0.4566405\",\n \"0.4548295\",\n \"0.4545266\",\n \"0.4538004\",\n \"0.45378256\",\n \"0.45352617\",\n \"0.45263907\",\n \"0.45255142\",\n \"0.4504833\",\n \"0.44985098\",\n \"0.4496821\",\n \"0.44963092\",\n \"0.44941193\",\n \"0.44938564\",\n \"0.4477105\",\n \"0.44717756\",\n \"0.44591832\",\n \"0.4457597\",\n \"0.44477665\",\n \"0.44275886\",\n \"0.4422899\",\n \"0.44005114\",\n \"0.43947035\",\n \"0.4383181\",\n \"0.43617284\",\n \"0.4357111\",\n \"0.4348767\",\n \"0.43408453\",\n \"0.43338823\",\n \"0.43234774\",\n \"0.43216935\",\n \"0.43183312\",\n \"0.4316178\",\n \"0.4316174\",\n \"0.43120253\",\n \"0.43100435\",\n \"0.43059316\",\n \"0.42963248\",\n \"0.42945355\",\n \"0.42942664\",\n \"0.4283655\",\n \"0.4282241\",\n \"0.4272585\",\n \"0.42696986\",\n \"0.426662\",\n \"0.42661366\",\n \"0.42584962\",\n \"0.42554128\",\n \"0.42460766\",\n \"0.42452443\",\n \"0.4243876\",\n \"0.42434978\",\n \"0.4242356\",\n \"0.4240616\",\n \"0.42393553\",\n \"0.42363828\",\n \"0.42346913\",\n \"0.42311624\",\n \"0.4229035\",\n \"0.42286488\",\n \"0.42244828\",\n \"0.42244604\",\n \"0.42204863\",\n \"0.42109975\",\n \"0.4209665\",\n \"0.42084795\",\n \"0.42033747\",\n \"0.42033142\",\n \"0.41988605\",\n \"0.41958228\",\n \"0.4193592\",\n \"0.4191341\",\n \"0.4181615\",\n \"0.41775793\",\n \"0.41771618\",\n \"0.41740996\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7271368"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20186,"cells":{"query":{"kind":"string","value":"Defines magic command ``%%mlnet``."},"document":{"kind":"string","value":"def mlnet(self, line, cell):\n line, cell = CsMagics._preprocess_line_cell_maml( # pylint: disable=W0212\n line, cell)\n\n parser = self.get_parser(CsMagics.CS_parser, \"CS\")\n args = self.get_args(line, parser)\n\n if args is not None:\n name = args.name\n dep = CsMagics._linearise_args(args.dep) # pylint: disable=W0212\n idep = CsMagics._linearise_args(args.idep) # pylint: disable=W0212\n\n if args.catch:\n try:\n f = mlnet(name, cell, idep, dep)\n except Exception as e: # pylint: disable=W0703\n print(str(e).replace('\\r', ''))\n return None\n else:\n f = mlnet(name, cell, idep, dep)\n if self.shell is not None:\n self.shell.user_ns[name] = f\n return f\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def mlnet_parser():\n parser = MagicCommandParser(prog=\"mlnet\",\n description='Compiles and wrap a C# function into a Python function.\\n'\n 'Automatically adds ML.net dependencies.')\n parser.add_argument('name', type=str, help='function name')\n parser.add_argument('-i', '--idep', nargs='*', action='append',\n help='internal dependencies (like System, System.Linq)')\n parser.add_argument('-d', '--dep', nargs='*', action='append',\n help='dependencies (assembly name without extension)')\n parser.add_argument('-c', '--catch', action='store', default=False,\n help='catch exception')\n return parser","def net_cmd(self):\n \n logging.debug(\"net_cmd called\")\n cmd = \"\"\n # FIXME should probably grab the PrefixLength from the network definition\n # calc my router\n \n # FIXME: Need to split this into separate files...\n # files will be a dictionary of {\"filename\":\"contents\"}\n files = {}\n \n cmd = \"rem cmd\\r\\n\"\n tmpl = \"\"\"netsh interface ip set address \"%(nic)s\" static %(v4_fixed_ip)s 255.255.255.0\\r\\n\"\"\"\n # FIXME: this should be read out of the configuration, probably\n nets = self.networks\n ips = self.ip_addresses \n my_router = \"\"\n for netname in nets:\n v4_fixed_ip = ips.get(netname)\n my_net = v4_fixed_ip.split(\".\")[:3]\n my_net.append(\"254\")\n my_router = \".\".join(my_net)\n nic = \"%s-%s\" % (self.footprint.footprint_name, netname)\n logging.debug(\"Creating %s for %s\" % (nic, nets))\n # net_id = self.networks.get(netname)\n cmd = cmd + tmpl % locals()\n \n cmd += \"\"\"route -p add 192.168.1.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n cmd += \"\"\"route -p add 192.168.2.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n cmd += \"\"\"route -p add 192.168.3.0 MASK 255.255.255.0 %(my_router)s\\r\\n\"\"\" % locals()\n logging.debug(\"cmdfile:\\n\" + cmd)\n \n # print 50 * \"x\"\n # print cmd\n return cmd","def niw_mmml_mp(args):\n return niw_mmml(*args)","def cmd_nlst(args):","def command(self, cmd):\n self.lmp.command(cmd)","def command(self,cmd):\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))","def _make_matlab_command(self):\n \n raise NotImplementedError","def resnet110m(**kwargs):\r\n return ResNet(BasicBlock, 110, mask=True, **kwargs)","def magic2python(cmd):\n\n if cmd.startswith('#@') or cmd.startswith('@'):\n if cmd[0]=='#':\n cmd = cmd[1:]\n # we need to return the proper line end later\n if cmd[-1] == '\\n':\n endl = '\\n'\n else:\n endl = ''\n try:\n func,args = cmd[1:].split(' ',1)\n except:\n func,args = cmd[1:].rstrip(),''\n args = args.replace('\"','\\\\\"').replace(\"'\",\"\\\\'\").rstrip()\n return '__IP.magic_%s (\"%s\")%s' % (func,args,endl)\n else:\n return cmd","def lncli(cmd, node_index):\n node = Node.from_index(node_index)\n run_lncli(node, cmd)","def cmd_mt_irc(word, word_eol, userdata):\n\tif len(word) > 1:\n\t\tsubcmd = word[1]\n\t\tif subcmd in subcommands:\n\t\t\tsubcmd = subcommands[subcmd]\n\t\t\tsubcmd(word[1:], word_eol[1:])\n\t\telse:\n\t\t\tprint('[mt_irc] Unknown subcommand \"%s\". Try \"/mt_irc help\".')\n\telse:\n\t\tprint('Usage: /mt_irc SUBCOMMAND')\n\t\tprint('Try \"/mt_irc help\".')\n\treturn xchat.EAT_XCHAT","def command(name):\n def _decoration(fcn):\n fcn.command = name\n return fcn\n return _decoration","def _magic_n(self, args):\n if idapy._d is None:\n print \"Please select a dump first. Example:\"\n print \"sel t2i\"\n return\n args = args.split(\" \")\n s,n = string.join(args[:-1], \" \"), args[-1]\n \n a = addr_from_magic_string(s, rounded_32bit = False)\n print \"NSTUB( 0x%X, %s )\" % (a, n)\n idapy._d.MakeName(a, n)","def resnet110(**kwargs):\r\n return ResNet(BasicBlock, 110, **kwargs)","def cg_label(self, cmd):\n label = self.makeLabel(cmd)\n self.asm(f\"({label})\")","def __getFullCommandName(self, command, type):\n return 'cmd_%s_%s' % (type, command)","def label(cmd):\r\n cmd = cmd.replace('make][.DP', 'make1][.NP')\r\n cmd = cmd.replace('make][.SC', 'make2][.SC')\r\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\r\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\r\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\r\n cmd = '[result ' + cmd + ']' #dummy function for plop\r\n return cmd","def test_shortopt(self):\n pp = ParlaiParser(False, False)\n pp.add_argument(\"-m\", \"--model\")\n pp.add_argument(\"-mtw\", \"--multitask-weights\")\n opt = pp.parse_args([\"-m\", \"memnn\"])\n print(opt)","def _mnasnet(arch, block, layers, expansions, kernel_sizes, SE, dropout=0,\n pretrained=False, progress=False, **kwargs):\n model = MnasNet(block, layers=layers, expansions=expansions, kernel_sizes=kernel_sizes,\n SE=SE, dropout=dropout, **kwargs)\n if pretrained:\n if arch in model_urls.keys():\n state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)\n model.load_state_dict(state_dict)\n return model","def label(cmd):\n cmd = cmd.replace('make][.DP', 'make1][.NP')\n cmd = cmd.replace('make][.SC', 'make2][.SC')\n cmd = re.sub('(draw.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make1.*)one','\\\\1one1',cmd)\n cmd = re.sub('(make2.*)one','\\\\1one2',cmd)\n cmd = re.sub('(move.*)one','\\\\1one2',cmd)\n cmd = re.sub('(hide.*)one','\\\\1one2',cmd)\n cmd = '[result ' + cmd + ']' #dummy function for plop\n return cmd","def _gen_cmd(cmd, address):\n family = {4: 'inet', 6: 'inet6'}[address[0].version]\n args = ['addr', cmd, '%s/%s' % (address[0], address[1])]\n if family == 'inet' and cmd == 'add':\n args += ['brd', '+']\n args += ['dev', real_ifname]\n if family == 'inet6':\n args = ['-6'] + args\n return args","def netz(self, mask, target, args):\n print('{mask} netz {args}'.format(mask=mask, args=args))\n nick = args['<nick>']\n if nick is None:\n nick = mask.nick\n yield self.bot.db.get(nick, {}).get('netz', None) or 'Nichts bekannt über {nick}'.format(nick=nick)","def cmd(name: str) -> Callable:\n return g.new_cmd_decorator(name, ['c', 'spellCommands',])","def meinnetz(self, mask, target, args):\n print('{mask} meinnetz {args}'.format(mask=mask, args=args))\n netz = args['<netz>'] or None\n if netz is not None:\n netz = ' '.join(netz)\n self.bot.db.set(mask.nick, netz=netz)\n yield 'ack'","def test_set_node_name_for_matmul_add_linear(self, export_args):\n class Linear(torch.nn.Module):\n def __init__(self):\n super(Linear, self).__init__()\n self.linear = torch.nn.Linear(3, 2)\n\n def forward(self, inp):\n x = self.linear(inp)\n return x\n\n model = Linear()\n # Using an input to linear op with dimension != 2 causes torch to use matmul->add instead of gemm op\n onnx_path = './data/MyModel.onnx'\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 1, 3), onnx_export_args=copy.deepcopy(export_args))\n onnx_model = onnx.load(onnx_path)\n expected_node_names = ['linear', 'linear#1.end']\n\n actual_node_names = [node.name for node in onnx_model.graph.node]\n for name in expected_node_names:\n assert name in actual_node_names\n\n expected_param_names = ['linear.weight', 'linear.bias']\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\n for name in expected_param_names:\n assert name in valid_param_set\n\n # Check that gemm still works as expected\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 3), onnx_export_args=copy.deepcopy(export_args))\n onnx_model = onnx.load(onnx_path)\n\n actual_node_names = [node.name for node in onnx_model.graph.node]\n assert 'linear' in actual_node_names\n assert 'linear#1' not in actual_node_names\n\n expected_param_names = ['linear.weight', 'linear.bias']\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\n for name in expected_param_names:\n assert name in valid_param_set\n\n self.check_onnx_node_name_uniqueness(onnx_model)\n\n if os.path.exists(onnx_path):\n os.remove(onnx_path)","def addMulticast(command, controlList):\n _addMulticast(command, controlList)","def get_name():\n\n return 'nettools'","def cmd(self, cmd):\n return cmd","def train_mann_multi(args):\n\n src = args.src\n tgt = args.tgt\n base_model = args.base_model\n num_cls = args.num_cls\n tgt_list = args.tgt_list\n num_epoch = args.mann_num_epoch\n batch = args.batch\n datadir = args.datadir\n outdir = args.outdir_mann\n src_weights = args.src_net_file\n lr = args.mann_lr\n betas = tuple(args.betas)\n weight_decay = args.weight_decay\n centroids_path = args.centroids_src_file\n feat_dim = 512\n\n ###########################\n # Setup cuda and networks #\n ###########################\n\n # setup cuda\n if torch.cuda.is_available():\n kwargs = {'num_workers': 8, 'pin_memory': True}\n else:\n kwargs = {}\n\n # setup network \n net = get_model('MannNet', model=base_model, num_cls=num_cls,\n src_weights_init=src_weights,\n centroids_path=centroids_path, feat_dim=feat_dim)\n \n # print network and arguments\n print(net)\n print('Training Mann {} model for {}->{}'.format(base_model, src, tgt))\n\n #######################################\n # Setup data for training and testing #\n #######################################\n train_src_data = load_data_multi(src, 'train', batch=batch,\n rootdir=join(datadir, src), num_channels=net.num_channels,\n image_size=net.image_size, download=True, kwargs=kwargs)\n\n train_tgt_data = load_data_multi(tgt_list, 'train', batch=batch, \n rootdir=datadir, num_channels=net.num_channels,\n image_size=net.image_size, download=True, kwargs=kwargs)\n\n ######################\n # Optimization setup #\n ######################\n opt_net = optim.Adam(net.tgt_net.parameters(), lr=lr, \n weight_decay=weight_decay, betas=betas)\n opt_dis = optim.Adam(net.discriminator.parameters(), lr=lr, \n weight_decay=weight_decay, betas=betas)\n opt_selector = optim.Adam(net.fc_selector.parameters(), lr=lr*0.1, \n weight_decay=weight_decay, betas=betas)\n opt_classifier = optim.Adam(net.classifier.parameters(), lr=lr*0.1, \n weight_decay=weight_decay, betas=betas)\n\n ##############\n # Train mann #\n ##############\n for epoch in range(num_epoch):\n err = train_epoch(train_src_data, train_tgt_data, net, opt_net, opt_dis, opt_selector, opt_classifier, epoch) \n if err == -1:\n print(\"No suitable discriminator\")\n break\n \n ##############\n # Save Model #\n ##############\n os.makedirs(outdir, exist_ok=True)\n outfile = join(outdir, 'mann_{:s}_net_{:s}_{:s}.pth'.format(base_model, src, tgt))\n print('Saving to', outfile)\n net.save(outfile)","def normal(command_strn):\n return Cmd('execute \"normal! {}\"'.format(command_strn))","def mobilenetv1(**kwargs):\n return MobileNet(**kwargs)","def build_command(args, parser):\n cmd = \"ipmitool -I lanplus\"\n if not args.host:\n print \"\\nERROR: hostname is required.\\n\"\n parser.print_help()\n sys.exit(1)\n else:\n cmd += ' -H ' + args.host\n if args.port:\n cmd += ' -p ' + args.port\n if not args.user:\n print \"\\nERROR: username is required.\\n\"\n parser.print_help()\n sys.exit(1)\n else:\n cmd += ' -U ' + args.user\n if args.passwd:\n cmd += ' -P ' + args.passwd\n cmd += ' dcmi power reading'\n if args.interval:\n global INTERVAL\n INTERVAL = args.interval\n if args.nread:\n global NREAD\n NREAD = args.nread\n else:\n global INFINITY\n INFINITY = True\n if args.store:\n global STORE\n STORE = True\n return cmd","def launch_builtin_module(cmd, args):\n\n launch_path = \"%s/core/cmds/%s.py\" % (utils.get_pydtf_dir(), cmd)\n\n return __launch_python_module(launch_path, cmd, args)","def send_to_ml(obj, ml_name: str):\n base.send_to_ml(obj, ml_name)","def _command(f, wrapper, syntax, namespace, internal=False):\n logger.info('command : syntax : {0}'.format(syntax))\n node = Tree.fnode(f, wrapper)\n node.command.syntax = syntax\n node.command.internal = internal\n if namespace:\n Tree().rename_node(node.name, '{0}.{1}'.format(namespace, f.__qualname__))\n node.command.build_command_parsing_tree()","def test_matmul_vm(self):\n self.check_dot_vm(matmul_usecase, None, \"'@'\")","def _DefaultLN(self, name):\n p = self.params\n return p.layernorm_tpl.Copy().Set(\n name=name,\n input_dim=p.model_dim,\n use_fused_layernorm=p.use_fused_layernorm,\n fprop_dtype=p.fprop_dtype)","def set_label(self):\n try:\n self.get_mask()\n except ex.excError:\n pass\n self.label = \"netns %s %s/%s %s@%s\" % (self.mode, self.ipname, to_cidr(self.mask), self.ipdev, self.container_rid)","def command_(self, name):\n def decorator(func):\n func.__name__ = name\n return self.command(func)\n return decorator","def interpret_nl(nl_string):\n if nl_string == 'relu':\n return tf.nn.relu\n elif nl_string == 'sigmoid':\n return tf.sigmoid\n elif nl_string == 'tanh':\n return tf.tanh\n else:\n raise NotImplementedError(nl_string)","def macro_network():\n # fmt: off\n tpm = np.array([\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 1.0, 1.0],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 1.0, 1.0],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 0.3, 0.3],\n [0.3, 0.3, 1.0, 1.0],\n [1.0, 1.0, 0.3, 0.3],\n [1.0, 1.0, 0.3, 0.3],\n [1.0, 1.0, 0.3, 0.3],\n [1.0, 1.0, 1.0, 1.0],\n ])\n # fmt: on\n return Network(tpm, node_labels=LABELS[:tpm.shape[1]])","def sendMulticast(command):\n _sendMulticast(command)","def test_rename_to_mlflow(mlflow):\n atom = ATOMClassifier(X_bin, y_bin, experiment=\"test\", random_state=1)\n atom.run(\"GNB\")\n atom.scoring()\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training","def mod_command(server, output):\n for target in output.message.split()[1:]:\n if target in server.ops:\n server.tell(output.name, '%s is an operator' % (target))\n continue\n if target in server.mods:\n server.tell(output.name, '%s is already a mod' % (target))\n else:\n server.mod(output, target)\n return","def __init__(self, *args):\n _snap.TMMNet_swiginit(self, _snap.new_TMMNet(*args))","def make_command(infile, *fns):\n fnargs = [measure_arg(fn) for fn in fns]\n return [lm_cmd] + fnargs + [infile]","def __init__(self, *args):\n _snap.TMMNetModeNetI_swiginit(self, _snap.new_TMMNetModeNetI(*args))","def make(self):\n\n return 'nmake'","def export_mlp(self):\n return self.net","def cmd_mdtm(args):","def register_command(self, func):\n self.commands[func.__name__] = func","def managed_network_name(self) -> pulumi.Input[str]:\n return pulumi.get(self, \"managed_network_name\")","def get_net(self,netname, mol = False):\n lines = self.mfp.get_net(netname)\n return lines","def define_command(self, name, command):\n code = (\"function %s {\"\n \" %s \\\"$@\\\"\\n\"\n \"}\") % (name, command)\n self._printer(code)","def _llm_type(self) -> str:\n return \"llama.cpp\"","def setNetmask(self):\n\t\tself.netmask = self.settings.getKeyValue('netmask')\n\t\tself.socket.send('setenv netmask ' + self.netmask+'\\r', 1)\n\t\treturn None","def get_default_MXNet_mode():\n return MXNET_DEFAULT_MODE","def resnet110g4(**kwargs):\r\n return ResNet(BasicBlock, 110, groups=4, **kwargs)","def magic_ll(self, parameter_s=''):\n self.magic_lc(parameter_s+' | grep ^l')","def getCommand(self, process, step=False, replica=None):\n replica = replica or self.replica\n if not replica: raise NAMDWriterError, \"Replica not assigned.\"\n\n if process == 'min':\n command = S.NAMD_EXE+' min.in &> min.out'\n return command\n\n elif process == 'eq':\n if not step: return False\n outname = replica.eqoutfiletemplate.format(step=step, extension='out')\n command = S.NAMD_EXE+' eq%i.in &> %s'%(step, outname)\n return command\n\n elif process == 'md':\n if not step: return False\n\n mdouttemplate=replica.mdoutfiletemplate.replace('.{extension}','')\n outname = mdouttemplate.format(step=step)\n command = S.NAMD_EXE+' %s.in &> %s.out'%(outname, outname)\n return command\n\n else: pass","def get_command(self, kword: str):\n # Step Zero is to make sure that the name does not belong to a REAL command.\n zero, mod = super().get_command(kword)\n if zero:\n return zero, mod\n\n # Otherwise, first, ensure that the keyword does in fact exist in the custom list.\n command = self.config.commands.get(kword, None)\n if not command:\n return None, None\n response = command[\"com\"]\n\n # Build the function to return the response. Note that \"self\" exists already.\n async def cmd_custom(args, src, **_):\n if args:\n member = self.get_member(src, args[0].strip())\n tag = member.mention if member else None\n else:\n tag = None\n\n nsfw = command.get(\"nsfw\", False)\n if nsfw and src.channel.id not in self.config.get(\"nsfwChannels\"):\n return None\n\n # Replace tags where needed.\n try:\n output = response.format(\n self=src.author.name,\n myID=src.author.id,\n tag=tag or src.author.mention,\n )\n except KeyError:\n return None\n else:\n return output\n\n # Specify the docstring and name so that !help will work on this.\n short = response.replace(\"{\", \"{{\").replace(\"}\", \"}}\")\n if len(short) > 80:\n short = short[:77] + \"...\"\n cmd_custom.__doc__ = (\n \"__Custom command__: Return the following text: ```{}```\\n\\n\".format(short)\n + command.get(\n \"desc\",\n \"This is a custom command, so available help text is limited, but at the same time, the command is very simple. All it does is return a string, although the string may include formatting tags for invoker name, invoker ID, and a targeted mention.\",\n )\n + \"\\n\\nSyntax: `{p}\"\n + kword.lower()\n + (\" <user_ID>\" if \"{tag}\" in response else \"\")\n + \"`\"\n )\n cmd_custom.__name__ = \"cmd_\" + kword.lower()\n\n return cmd_custom, None","def simple_net(**kwargs):\n model = SimpleNet(BasicBlock, [1, 2, 1, 1, 1], [64]*5, **kwargs)\n return model","def model_fn(model_dir):\n\n net = gluon.nn.SymbolBlock.imports('%s/model.json' % model_dir,\n ['data'], \n param_file='%s/model.params' % model_dir,\n ctx=mx.cpu())\n\n return net","def graph_cmd(args):\n\n # charge graphviz\n Digraph = load_graphviz()\n\n view = True\n for i in args:\n if i == \"noview\":\n view = False\n args.remove(i)\n break\n\n if len(args) > 0:\n if len(args) >= 2:\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \"traverse\":args[1], \"mibs\":\"base\" })\n else:\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \"mibs\":\"base\" })\n else:\n r = requete('NeMo.Intf.lo:getMIBs', { \"traverse\":\"all\", \"mibs\":\"base\" })\n if r is None: return\n if not 'status' in r or not 'base' in r['status']: return\n r = r['status']['base']\n\n dot = Digraph(name='NeMo.Intf', format='svg', engine='dot')\n\n dot.attr('node', fontname='Helvetica')\n #dot.attr('node', fontname='Times-Roman')\n\n for i, node in r.items():\n #dot.attr('node', tooltip=v['Flags'] if 'Flags' in v else '')\n if 'Enable' in node:\n if node['Enable'] == True:\n dot.node(i, shape='box')\n else:\n dot.node(i, shape='ellipse', color='lightgrey')\n else:\n dot.node(i, shape='box', color='lightgrey')\n\n for i, v in r.items():\n for j in v['LLIntf']:\n dot.edge(i, j)\n\n dot.render(filename=\"nemo_intf.gv\", view=view)","def test_macro(self):\n with Graph('g') as graph:\n a = pike.placeholder()\n m = graph.macro(a)\n g1 = m(ParrotNode('foo'))\n g2 = m(ParrotNode('bar'))\n self.assertEqual(g1.run(), {'default': 'foo'})\n self.assertEqual(g2.run(), {'default': 'bar'})","def cmd(self):","def run_ntcontribs(args):\n nt_map(args)","def nameCommand(*args, annotation: AnyStr=\"\", command: Script=None, data1: AnyStr=\"\", data2:\n AnyStr=\"\", data3: AnyStr=\"\", default: bool=True, sourceType: AnyStr=\"\",\n **kwargs)->AnyStr:\n pass","def set_net_control(self, net_control: list) -> str:\n if not net_control:\n return\n net_control_list = \"\"\n for host in net_control[1:]:\n net_control_list += host[\"hostName\"] + \"\\r\" + host[\"mac\"] + \\\n \"\\r\" + host[\"limitUp\"] + \"\\r\" + host[\"limitDown\"] + \"\\n\"\n return self._req_post(self._URLS['SetNetControl'], data={\"list\": net_control_list})","def do_nmap__Auxilary(self, param):\n if self.which(\"nmap\"):\n self.do_shell(\"nmap \" + param)","def resnet110g8(**kwargs):\r\n return ResNet(BasicBlock, 110, groups=8, **kwargs)","def netlogo_args():\n return {\n \"model\": \"/home/smitty/proj/css600transp/css600transp/FireSim.nlogo\",\n \"setup-file\": \"setup-file.xml\",\n \"experiment\": \"FireSim\",\n \"threads\": \"1\",\n \"table\": \"-\",\n }","def makeLabel(self, cmd):\n if cmd.type in ['Function', 'Call']:\n return cmd.arg1\n\n if self.current_function_name is not None:\n prefix = self.current_function_name\n else:\n prefix = self.ns\n return prefix + '$' + cmd.arg1","def comando_nfce(self):\r\n return self.template_nfce()","def mgcNetArch(self, **kwargs):\n\n def_vals = {\"input_img_rows\" : self.input_img_rows,\n \"input_img_cols\" : self.input_img_cols,\n \"channels\" : self.channels,\n \"nb_classes\" : self.nb_classes,\n \"outLayer\" : 'gloAvg', \n \"l2_val\" : 0.00, \n \"net_architr\" : 'cnn_max', \n \"block_typex\" : 'basic', \n \"block_repeatx\" : [1, 1]\n }\n\n\n for k, v in def_vals.items():\n kwargs.setdefault(k, v)\n\n _input_img_rows = kwargs['input_img_rows']\n _input_img_cols = kwargs['input_img_cols']\n _channels = kwargs['channels']\n _nb_classes = kwargs['nb_classes']\n _outLayer = kwargs['outLayer']\n _l2_val = kwargs['l2_val']\n _net_architr = kwargs['net_architr']\n _block_typex = kwargs['block_typex']\n _block_repeatx = kwargs['block_repeatx']\n \n \n params = {\"input_img_rows\" : _input_img_rows,\n \"input_img_cols\" : _input_img_cols,\n \"channels\" : _channels,\n \"nb_classes\" : _nb_classes\n }\n \n print(_net_architr)\n if _net_architr == 'cnn_max':\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'cnn_stride':\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'cnn_stride_mini':\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'common_cnn':\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'net_in_net':\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n elif _net_architr == 'resnet':\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\n \n elif _net_architr == 'resblock':\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\n\n elif _net_architr == 'skipconnect':\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\n elif _net_architr == 'skipconnect_mini':\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\n \n self.model = model\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\n #self.model_summary = model.summary() \n \n return self","def niw_mmml(X, lambda_0, mu_0, kappa_0, nu_0, crp_alpha, Z_start, k_start,\n hist_start, ncalc):\n ml = lgniwmmml(X, lambda_0, mu_0, kappa_0, nu_0, crp_alpha, Z_start,\n k_start, hist_start, ncalc)\n return ml","def brain(msg):\n\n def check_message(msg):\n \"\"\"\n Check wich neuron to use.\n :param msg:\n :return:\n \"\"\"\n words_of_message = msg.split()\n find = False\n for key in gc_words:\n if words_of_message in gc_words[key]['groups']:\n getattr(neuron.general_conversations, key)()\n find = True\n break\n for key in fc_words:\n if words_of_message in fc_words[key]['groups']:\n getattr(neuron.forecast, key)()\n find = True\n break\n for key in twitter_words:\n if words_of_message in twitter_words[key]['groups']:\n getattr(neuron.twitter, key)()\n find = True\n break\n for key in pipo_words:\n if words_of_message in pipo_words[key]['groups']:\n getattr(neuron.pipotron, key)()\n find = True\n break\n if not find:\n neuron.general_conversations.undefined()\n\n check_message(msg)","def command(fxn):\n\tCMDTABLE[fxn.__name__] = (fxn, fxn.__doc__)\n\treturn fxn","def resnet34(**kwargs):\n model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)\n return model","def main_net_args(parser, allowed_nets=['fc'], dfc_arch='100,100',\n dmlp_arch='100,100', show_net_act=True, dnet_act='relu',\n show_no_bias=False, show_dropout_rate=True,\n ddropout_rate=-1, show_specnorm=True, show_batchnorm=True,\n show_no_batchnorm=False, show_bn_no_running_stats=False,\n show_bn_distill_stats=False,\n show_bn_no_stats_checkpointing=False,\n prefix=None, pf_name=None):\n assert(prefix is None or pf_name is not None)\n\n # TODO Delete 'fc' from list.\n for nt in allowed_nets:\n assert(nt in ['fc', 'mlp', 'resnet', 'zenke', 'bio_conv_net'])\n\n assert(not show_batchnorm or not show_no_batchnorm)\n\n # TODO 'fc' should be renamed to 'mlp'.\n if 'fc' in allowed_nets and len(allowed_nets) == 1:\n warn('Network type \"fc\" is deprecated. Default value of argument ' +\n '\"allowed_nets\" will be changed to [\\'mlp\\'] in the future!',\n DeprecationWarning)\n elif 'fc' in allowed_nets:\n # TODO change warning into error at some point.\n warn('Network type \"fc\" is deprecated! Use \"mlp\" instead.',\n DeprecationWarning)\n if 'fc' in allowed_nets and 'mlp' in allowed_nets:\n # Doesn't make sense to have both.\n raise ValueError('Network type names \"fc\" and \"mlp\" refer to the ' +\n 'same network type! Note, \"fc\" is deprecated.')\n\n heading = 'Main network options'\n\n if prefix is None:\n prefix = ''\n pf_name = ''\n else:\n heading = 'Main network options for %s network' % pf_name\n pf_name += ' '\n\n # Abbreviations.\n p = prefix\n n = pf_name\n\n ### Main network options.\n agroup = parser.add_argument_group(heading)\n\n if len(allowed_nets) > 1:\n agroup.add_argument('--%snet_type' % p, type=str,\n default=allowed_nets[0],\n help='Type of network to be used for this %s ' % n +\n 'network. Default: %(default)s.',\n choices=allowed_nets)\n\n # DELETEME once we delete option 'fc'.\n if 'fc' in allowed_nets:\n agroup.add_argument('--%sfc_arch' % p, type=str, default=dfc_arch,\n help='If using a \"fc\" %s network, this will ' % n +\n 'specify the hidden layers. ' +\n 'Default: %(default)s.')\n\n if 'mlp' in allowed_nets:\n agroup.add_argument('--%smlp_arch' % p, type=str, default=dmlp_arch,\n help='If using a \"mlp\" %s network, this will ' % n +\n 'specify the hidden layers. ' +\n 'Default: %(default)s.')\n\n # Note, if you want to add more activation function choices here, you have\n # to add them to the corresponding function `utils.misc.str_to_act` as well!\n if show_net_act:\n agroup.add_argument('--%snet_act' % p, type=str, default=dnet_act,\n help='Activation function used in the %s network.' % n +\n 'If \"linear\", no activation function is used. ' +\n 'Default: %(default)s.',\n choices=['linear', 'sigmoid', 'relu', 'elu'])\n\n if show_no_bias:\n agroup.add_argument('--%sno_bias' % p, action='store_true',\n help='No biases will be used in the %s network. ' % n +\n 'Note, does not affect normalization (like ' +\n 'batchnorm).')\n\n if show_dropout_rate:\n agroup.add_argument('--%sdropout_rate' % p, type=float,\n default=ddropout_rate,\n help='Use dropout in the %s network with the ' % n +\n 'given dropout probability (dropout is ' +\n 'deactivated for a rate of -1). Default: ' +\n '%(default)s.')\n\n if show_specnorm:\n agroup.add_argument('--%sspecnorm' % p, action='store_true',\n help='Enable spectral normalization in the ' +\n '%s network.' % n)\n\n ### Batchnorm related options.\n if show_batchnorm:\n agroup.add_argument('--%sbatchnorm' % p, action='store_true',\n help='Enable batchnorm in the %s network.' % n)\n if show_no_batchnorm:\n agroup.add_argument('--%sno_batchnorm' % p, action='store_true',\n help='Disable batchnorm in the %s network.' % n)\n\n if show_bn_no_running_stats:\n agroup.add_argument('--%sbn_no_running_stats' % p, action='store_true',\n help='If batch normalization is used, then this ' +\n 'option will deactivate the tracking ' +\n 'of running statistics. Hence, statistics ' +\n 'computed per batch will be used during ' +\n 'evaluation.')\n\n if show_bn_distill_stats:\n agroup.add_argument('--%sbn_distill_stats' % p, action='store_true',\n help='If batch normalization is used, ' +\n 'then usually the running statistics are ' +\n 'checkpointed for every task (e.g., in ' +\n 'continual learning), which has linearly ' +\n 'increasing memory requirements. If ' +\n 'this option is activated, the running ' +\n 'statistics will be distilled into the ' +\n 'hypernetwork after training each task, ' +\n 'such that only the statistics of the ' +\n 'current and previous task have to be ' +\n 'explicitly kept in memory')\n\n if show_bn_no_stats_checkpointing:\n agroup.add_argument('--%sbn_no_stats_checkpointing' % p,\n action='store_true',\n help='If batch normalization is used, then' +\n 'this option will prevent the checkpointing' +\n 'of batchnorm statistics for every task.' +\n 'In this case, one set of statistics is ' +\n 'used for all tasks.')\n\n return agroup","def make_mlp_likelihood_rlssm(\n model=None, model_config=None, model_config_rl=None, wiener_params=None, **kwargs\n):\n\n def make_likelihood():\n likelihood_str = make_likelihood_str_mlp_rlssm(\n model=model,\n config=model_config,\n config_rl=model_config_rl,\n wiener_params=wiener_params,\n )\n exec(likelihood_str)\n my_fun = locals()[\"custom_likelihood\"]\n return my_fun\n\n likelihood_ = make_likelihood()\n\n wfpt_nn_rl = stochastic_from_dist(\n \"WienernnRL_\" + model, partial(likelihood_, **kwargs)\n )\n\n return wfpt_nn_rl","def test_matmul_mm(self):\n self.check_dot_mm(matmul_usecase, None, \"'@'\")","def _llm_type(self) -> str:\n return \"openai\"","def set_model_gripper_command(robot,limb,command):\n qrobot = robot.getConfig()\n qhand = gripper.commandToConfig(command)\n if limb=='left':\n print \"Opening left gripper to\",command\n for i in range(gripper.numDofs):\n qrobot[left_hand_link_start+i] = qhand[i]\n # else:\n # print \"Opening right gripper to\",command\n # for i in range(gripper.numDofs):\n # qrobot[right_hand_link_start+i] = qhand[i]\n robot.setConfig(qrobot)","def but_load_net(self):\n a = tk.filedialog.askopenfilename(filetypes = [('NN file',['*.csv','*.pt'])])\n self.nn_obj=load_nn(a)","def expose_magic(magicname, func):\n \n from IPython import Magic\n import new\n im = new.instancemethod(func,__IP, __IP.__class__)\n setattr(__IP, \"magic_\" + magicname, im)","def type_command(ctx, name_from, name_to):","def mobilenet(path = \"\"):\n lr='0.0005'\n model = create_mobilenet(48, 0.5)\n layer_name=[]\n files = os.listdir(path)\n for layer in model.layers:\n check = path + \"/\" + layer.name + \".png\"\n if check in [path+'/'+f for f in files]:\n if 'conv' in layer.name and (not 'bn' in layer.name) and (not 'pad' in layer.name) and (not 'relu' in layer.name):\n layer_name.append([check,[layer.name ,str(layer.kernel_size[0]) + ' x ' + str(layer.kernel_size[1]), '-']])\n else:\n layer_name.append([check,[layer.name,'-', '-']])\n return layer_name","def makecmd(self, options):","def resnet18(**kwargs):\n model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)\n return model","def ResNetLN18(num_classes=10):\n return ResNet(BasicLNBlock, \n [2, 2, 2, 2], \n num_classes=num_classes,\n norm_type=\"LN\")","def intf_MMLIST(E):\n print(MMEL.__repr__())\n #print(OUT.default(MMEL,E))","def resnet34(**kwargs):\n model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)\n\n return model","def lt_command(self):\n self.write(\n \"@SP\\nA=M-1\\nD=M\\n@NEG1\" + str(\n self.__label_num) + \"\\nD;JLT\\n@POS1\" + str(\n self.__label_num) +\n \"\\nD;JGE\\n(NEG1\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nA=A-1\\nD=M\\n@POS2\" + str(\n self.__label_num) + \"\\nD;JGT\\n@CONT\"\n + str(self.__label_num) + \"\\n0;JMP\\n(POS1\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nA=A-1\\nD=M\\n@NEG2\" +\n str(self.__label_num) + \"\\nD;JLT\\n@CONT\" + str(\n self.__label_num) + \"\\n0;JMP\\n(POS2\" + str(\n self.__label_num) + \")\\n@SP\"\n \"\\nA=M-1\\nA=A-1\\nM=0\\n@SP\\nM=M-1\\n@ENDLABEL\" + str(\n self.__label_num) + \"\\n0;JMP\\n(NEG2\" + str(\n self.__label_num) + \")\\n@SP\" +\n \"\\nA=M-1\\nA=A-1\\nM=-1\\n@SP\\nM=M-1\\n@ENDLABEL\" + str(\n self.__label_num) + \"\\n0;JMP\\n(CONT\" + str(\n self.__label_num) + \")\\n\"\n \"@SP\\nM=M-1\\nA=M\\nD=M\\n@SP\\nA=M-1\\nD=M-D\\n@TRUE\" + str(\n self.__label_num) + \"\\nD;JGE\\n@SP\\nA=M-1\\nM=-1\\n@ENDLABEL\" +\n str(self.__label_num) + \"\\n0;JMP\\n(TRUE\" + str(\n self.__label_num) + \")\\n@SP\\nA=M-1\\nM=0\\n(ENDLABEL\" +\n str(self.__label_num) + \")\\n\")","def __getattr__(self, cmd):\n\n if hasattr(self._rpc, cmd+'Request'):\n lnfunc = getattr(self._rpc, cmd+'Request')\n elif hasattr(self._rpc, f'Get{cmd}Request'):\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\n else:\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\n\n if hasattr(self._stub, cmd):\n stubfunc = getattr(self._stub, cmd)\n\n def rpcCommand(*args,**kwargs):\n return stubfunc(lnfunc(*args, **kwargs))\n return rpcCommand\n\n elif hasattr(self._stub, 'Get'+cmd):\n stubfunc = getattr(self._stub, 'Get'+cmd)\n def rpcCommand(*args,**kwargs):\n if args:\n raise TypeError('Cannot use positional arguments with this command')\n return stubfunc(lnfunc(**kwargs))\n return rpcCommand\n\n else:\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)","def command():\n pass","def parse_args():\n parser = argparse.ArgumentParser(description='MXNet Gluon Semantic Segmentation')\n # model and dataset\n parser.add_argument('--model', type=str, default='fcn',\n help='model name (default: fcn)')\n parser.add_argument('--model-zoo', type=str, default=None,\n help='evaluating on model zoo model')\n parser.add_argument('--pretrained', action=\"store_true\",\n help='whether to use pretrained params')\n parser.add_argument('--backbone', type=str, default='resnet50',\n help='backbone name (default: resnet50)')\n parser.add_argument('--dataset', type=str, default='pascal',\n help='dataset name (default: pascal)')\n parser.add_argument('--workers', type=int, default=16,\n metavar='N', help='dataloader threads')\n parser.add_argument('--base-size', type=int, default=520,\n help='base image size')\n parser.add_argument('--crop-size', type=int, default=480,\n help='crop image size')\n parser.add_argument('--train-split', type=str, default='train',\n help='dataset train split (default: train)')\n # training hyper params\n parser.add_argument('--aux', action='store_true', default=False,\n help='Auxiliary loss')\n parser.add_argument('--aux-weight', type=float, default=0.5,\n help='auxiliary loss weight')\n parser.add_argument('--epochs', type=int, default=50, metavar='N',\n help='number of epochs to train (default: 50)')\n parser.add_argument('--start_epoch', type=int, default=0,\n metavar='N', help='start epochs (default:0)')\n parser.add_argument('--batch-size', type=int, default=16,\n metavar='N', help='input batch size for \\\n training (default: 16)')\n parser.add_argument('--test-batch-size', type=int, default=16,\n metavar='N', help='input batch size for \\\n testing (default: 16)')\n parser.add_argument('--optimizer', type=str, default='sgd',\n help='optimizer (default: sgd)')\n parser.add_argument('--lr', type=float, default=1e-3, metavar='LR',\n help='learning rate (default: 1e-3)')\n parser.add_argument('--warmup-epochs', type=int, default=0,\n help='number of warmup epochs.')\n parser.add_argument('--momentum', type=float, default=0.9,\n metavar='M', help='momentum (default: 0.9)')\n parser.add_argument('--weight-decay', type=float, default=1e-4,\n metavar='M', help='w-decay (default: 1e-4)')\n parser.add_argument('--no-wd', action='store_true',\n help='whether to remove weight decay on bias, \\\n and beta/gamma for batchnorm layers.')\n parser.add_argument('--mode', type=str, default=None,\n help='whether to turn on model hybridization')\n # cuda and distribute\n parser.add_argument('--no-cuda', action='store_true', default=False,\n help='disables CUDA training')\n parser.add_argument('--ngpus', type=int,\n default=len(mx.test_utils.list_gpus()),\n help='number of GPUs (default: 4)')\n parser.add_argument('--kvstore', type=str, default='device',\n help='kvstore to use for trainer/module.')\n parser.add_argument('--dtype', type=str, default='float32',\n help='data type for training. default is float32')\n # checking point\n parser.add_argument('--resume', type=str, default=None,\n help='put the path to resuming file if needed')\n parser.add_argument('--checkname', type=str, default='default',\n help='set the checkpoint name')\n parser.add_argument('--save-dir', type=str, default=None,\n help='directory of saved models')\n parser.add_argument('--log-interval', type=int, default=20,\n help='Number of batches to wait before logging.')\n parser.add_argument('--logging-file', type=str, default='train.log',\n help='name of training log file')\n # evaluation only\n parser.add_argument('--eval', action='store_true', default=False,\n help='evaluation only')\n parser.add_argument('--no-val', action='store_true', default=False,\n help='skip validation during training')\n # synchronized Batch Normalization\n parser.add_argument('--syncbn', action='store_true', default=False,\n help='using Synchronized Cross-GPU BatchNorm')\n # the parser\n args = parser.parse_args()\n\n # handle contexts\n if args.no_cuda:\n print('Using CPU')\n args.kvstore = 'local'\n args.ctx = [mx.cpu(0)]\n else:\n print('Number of GPUs:', args.ngpus)\n assert args.ngpus > 0, 'No GPUs found, please enable --no-cuda for CPU mode.'\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\n\n if 'psp' in args.model or 'deeplab' in args.model:\n assert args.crop_size % 8 == 0, ('For PSPNet and DeepLabV3 model families, '\n 'we only support input crop size as multiples of 8.')\n\n # logging and checkpoint saving\n if args.save_dir is None:\n args.save_dir = \"runs/%s/%s/%s/\" % (args.dataset, args.model, args.backbone)\n makedirs(args.save_dir)\n\n # Synchronized BatchNorm\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\n else mx.gluon.nn.BatchNorm\n args.norm_kwargs = {'num_devices': args.ngpus} if args.syncbn else {}\n return args","def setNetmask(self, netmask):\n # type: (str)->None\n\n self._validator.validate_one(\n 'netmask', VALID_OPTS['netmask'], netmask)\n self._ifAttributes['netmask'] = netmask","def add(self, name, command):","def ReadNet(model_def):\n with open(model_def) as f:\n net = cp.NetParameter()\n pb.text_format.Parse(f.read(), net)\n return net"],"string":"[\n \"def mlnet_parser():\\n parser = MagicCommandParser(prog=\\\"mlnet\\\",\\n description='Compiles and wrap a C# function into a Python function.\\\\n'\\n 'Automatically adds ML.net dependencies.')\\n parser.add_argument('name', type=str, help='function name')\\n parser.add_argument('-i', '--idep', nargs='*', action='append',\\n help='internal dependencies (like System, System.Linq)')\\n parser.add_argument('-d', '--dep', nargs='*', action='append',\\n help='dependencies (assembly name without extension)')\\n parser.add_argument('-c', '--catch', action='store', default=False,\\n help='catch exception')\\n return parser\",\n \"def net_cmd(self):\\n \\n logging.debug(\\\"net_cmd called\\\")\\n cmd = \\\"\\\"\\n # FIXME should probably grab the PrefixLength from the network definition\\n # calc my router\\n \\n # FIXME: Need to split this into separate files...\\n # files will be a dictionary of {\\\"filename\\\":\\\"contents\\\"}\\n files = {}\\n \\n cmd = \\\"rem cmd\\\\r\\\\n\\\"\\n tmpl = \\\"\\\"\\\"netsh interface ip set address \\\"%(nic)s\\\" static %(v4_fixed_ip)s 255.255.255.0\\\\r\\\\n\\\"\\\"\\\"\\n # FIXME: this should be read out of the configuration, probably\\n nets = self.networks\\n ips = self.ip_addresses \\n my_router = \\\"\\\"\\n for netname in nets:\\n v4_fixed_ip = ips.get(netname)\\n my_net = v4_fixed_ip.split(\\\".\\\")[:3]\\n my_net.append(\\\"254\\\")\\n my_router = \\\".\\\".join(my_net)\\n nic = \\\"%s-%s\\\" % (self.footprint.footprint_name, netname)\\n logging.debug(\\\"Creating %s for %s\\\" % (nic, nets))\\n # net_id = self.networks.get(netname)\\n cmd = cmd + tmpl % locals()\\n \\n cmd += \\\"\\\"\\\"route -p add 192.168.1.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n cmd += \\\"\\\"\\\"route -p add 192.168.2.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n cmd += \\\"\\\"\\\"route -p add 192.168.3.0 MASK 255.255.255.0 %(my_router)s\\\\r\\\\n\\\"\\\"\\\" % locals()\\n logging.debug(\\\"cmdfile:\\\\n\\\" + cmd)\\n \\n # print 50 * \\\"x\\\"\\n # print cmd\\n return cmd\",\n \"def niw_mmml_mp(args):\\n return niw_mmml(*args)\",\n \"def cmd_nlst(args):\",\n \"def command(self, cmd):\\n self.lmp.command(cmd)\",\n \"def command(self,cmd):\\n self.lib.lammps_command(self.lmp,cmd.encode('utf-8'))\",\n \"def _make_matlab_command(self):\\n \\n raise NotImplementedError\",\n \"def resnet110m(**kwargs):\\r\\n return ResNet(BasicBlock, 110, mask=True, **kwargs)\",\n \"def magic2python(cmd):\\n\\n if cmd.startswith('#@') or cmd.startswith('@'):\\n if cmd[0]=='#':\\n cmd = cmd[1:]\\n # we need to return the proper line end later\\n if cmd[-1] == '\\\\n':\\n endl = '\\\\n'\\n else:\\n endl = ''\\n try:\\n func,args = cmd[1:].split(' ',1)\\n except:\\n func,args = cmd[1:].rstrip(),''\\n args = args.replace('\\\"','\\\\\\\\\\\"').replace(\\\"'\\\",\\\"\\\\\\\\'\\\").rstrip()\\n return '__IP.magic_%s (\\\"%s\\\")%s' % (func,args,endl)\\n else:\\n return cmd\",\n \"def lncli(cmd, node_index):\\n node = Node.from_index(node_index)\\n run_lncli(node, cmd)\",\n \"def cmd_mt_irc(word, word_eol, userdata):\\n\\tif len(word) > 1:\\n\\t\\tsubcmd = word[1]\\n\\t\\tif subcmd in subcommands:\\n\\t\\t\\tsubcmd = subcommands[subcmd]\\n\\t\\t\\tsubcmd(word[1:], word_eol[1:])\\n\\t\\telse:\\n\\t\\t\\tprint('[mt_irc] Unknown subcommand \\\"%s\\\". Try \\\"/mt_irc help\\\".')\\n\\telse:\\n\\t\\tprint('Usage: /mt_irc SUBCOMMAND')\\n\\t\\tprint('Try \\\"/mt_irc help\\\".')\\n\\treturn xchat.EAT_XCHAT\",\n \"def command(name):\\n def _decoration(fcn):\\n fcn.command = name\\n return fcn\\n return _decoration\",\n \"def _magic_n(self, args):\\n if idapy._d is None:\\n print \\\"Please select a dump first. Example:\\\"\\n print \\\"sel t2i\\\"\\n return\\n args = args.split(\\\" \\\")\\n s,n = string.join(args[:-1], \\\" \\\"), args[-1]\\n \\n a = addr_from_magic_string(s, rounded_32bit = False)\\n print \\\"NSTUB( 0x%X, %s )\\\" % (a, n)\\n idapy._d.MakeName(a, n)\",\n \"def resnet110(**kwargs):\\r\\n return ResNet(BasicBlock, 110, **kwargs)\",\n \"def cg_label(self, cmd):\\n label = self.makeLabel(cmd)\\n self.asm(f\\\"({label})\\\")\",\n \"def __getFullCommandName(self, command, type):\\n return 'cmd_%s_%s' % (type, command)\",\n \"def label(cmd):\\r\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\r\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\r\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\r\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\r\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\r\\n return cmd\",\n \"def test_shortopt(self):\\n pp = ParlaiParser(False, False)\\n pp.add_argument(\\\"-m\\\", \\\"--model\\\")\\n pp.add_argument(\\\"-mtw\\\", \\\"--multitask-weights\\\")\\n opt = pp.parse_args([\\\"-m\\\", \\\"memnn\\\"])\\n print(opt)\",\n \"def _mnasnet(arch, block, layers, expansions, kernel_sizes, SE, dropout=0,\\n pretrained=False, progress=False, **kwargs):\\n model = MnasNet(block, layers=layers, expansions=expansions, kernel_sizes=kernel_sizes,\\n SE=SE, dropout=dropout, **kwargs)\\n if pretrained:\\n if arch in model_urls.keys():\\n state_dict = load_state_dict_from_url(model_urls[arch], progress=progress)\\n model.load_state_dict(state_dict)\\n return model\",\n \"def label(cmd):\\n cmd = cmd.replace('make][.DP', 'make1][.NP')\\n cmd = cmd.replace('make][.SC', 'make2][.SC')\\n cmd = re.sub('(draw.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make1.*)one','\\\\\\\\1one1',cmd)\\n cmd = re.sub('(make2.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(move.*)one','\\\\\\\\1one2',cmd)\\n cmd = re.sub('(hide.*)one','\\\\\\\\1one2',cmd)\\n cmd = '[result ' + cmd + ']' #dummy function for plop\\n return cmd\",\n \"def _gen_cmd(cmd, address):\\n family = {4: 'inet', 6: 'inet6'}[address[0].version]\\n args = ['addr', cmd, '%s/%s' % (address[0], address[1])]\\n if family == 'inet' and cmd == 'add':\\n args += ['brd', '+']\\n args += ['dev', real_ifname]\\n if family == 'inet6':\\n args = ['-6'] + args\\n return args\",\n \"def netz(self, mask, target, args):\\n print('{mask} netz {args}'.format(mask=mask, args=args))\\n nick = args['<nick>']\\n if nick is None:\\n nick = mask.nick\\n yield self.bot.db.get(nick, {}).get('netz', None) or 'Nichts bekannt über {nick}'.format(nick=nick)\",\n \"def cmd(name: str) -> Callable:\\n return g.new_cmd_decorator(name, ['c', 'spellCommands',])\",\n \"def meinnetz(self, mask, target, args):\\n print('{mask} meinnetz {args}'.format(mask=mask, args=args))\\n netz = args['<netz>'] or None\\n if netz is not None:\\n netz = ' '.join(netz)\\n self.bot.db.set(mask.nick, netz=netz)\\n yield 'ack'\",\n \"def test_set_node_name_for_matmul_add_linear(self, export_args):\\n class Linear(torch.nn.Module):\\n def __init__(self):\\n super(Linear, self).__init__()\\n self.linear = torch.nn.Linear(3, 2)\\n\\n def forward(self, inp):\\n x = self.linear(inp)\\n return x\\n\\n model = Linear()\\n # Using an input to linear op with dimension != 2 causes torch to use matmul->add instead of gemm op\\n onnx_path = './data/MyModel.onnx'\\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 1, 3), onnx_export_args=copy.deepcopy(export_args))\\n onnx_model = onnx.load(onnx_path)\\n expected_node_names = ['linear', 'linear#1.end']\\n\\n actual_node_names = [node.name for node in onnx_model.graph.node]\\n for name in expected_node_names:\\n assert name in actual_node_names\\n\\n expected_param_names = ['linear.weight', 'linear.bias']\\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\\n for name in expected_param_names:\\n assert name in valid_param_set\\n\\n # Check that gemm still works as expected\\n onnx_utils.OnnxSaver.set_node_names(onnx_path, model, dummy_input=torch.randn(1, 3), onnx_export_args=copy.deepcopy(export_args))\\n onnx_model = onnx.load(onnx_path)\\n\\n actual_node_names = [node.name for node in onnx_model.graph.node]\\n assert 'linear' in actual_node_names\\n assert 'linear#1' not in actual_node_names\\n\\n expected_param_names = ['linear.weight', 'linear.bias']\\n _, valid_param_set = onnx_utils.OnnxSaver.get_onnx_node_to_io_tensor_names_map(onnx_model)\\n for name in expected_param_names:\\n assert name in valid_param_set\\n\\n self.check_onnx_node_name_uniqueness(onnx_model)\\n\\n if os.path.exists(onnx_path):\\n os.remove(onnx_path)\",\n \"def addMulticast(command, controlList):\\n _addMulticast(command, controlList)\",\n \"def get_name():\\n\\n return 'nettools'\",\n \"def cmd(self, cmd):\\n return cmd\",\n \"def train_mann_multi(args):\\n\\n src = args.src\\n tgt = args.tgt\\n base_model = args.base_model\\n num_cls = args.num_cls\\n tgt_list = args.tgt_list\\n num_epoch = args.mann_num_epoch\\n batch = args.batch\\n datadir = args.datadir\\n outdir = args.outdir_mann\\n src_weights = args.src_net_file\\n lr = args.mann_lr\\n betas = tuple(args.betas)\\n weight_decay = args.weight_decay\\n centroids_path = args.centroids_src_file\\n feat_dim = 512\\n\\n ###########################\\n # Setup cuda and networks #\\n ###########################\\n\\n # setup cuda\\n if torch.cuda.is_available():\\n kwargs = {'num_workers': 8, 'pin_memory': True}\\n else:\\n kwargs = {}\\n\\n # setup network \\n net = get_model('MannNet', model=base_model, num_cls=num_cls,\\n src_weights_init=src_weights,\\n centroids_path=centroids_path, feat_dim=feat_dim)\\n \\n # print network and arguments\\n print(net)\\n print('Training Mann {} model for {}->{}'.format(base_model, src, tgt))\\n\\n #######################################\\n # Setup data for training and testing #\\n #######################################\\n train_src_data = load_data_multi(src, 'train', batch=batch,\\n rootdir=join(datadir, src), num_channels=net.num_channels,\\n image_size=net.image_size, download=True, kwargs=kwargs)\\n\\n train_tgt_data = load_data_multi(tgt_list, 'train', batch=batch, \\n rootdir=datadir, num_channels=net.num_channels,\\n image_size=net.image_size, download=True, kwargs=kwargs)\\n\\n ######################\\n # Optimization setup #\\n ######################\\n opt_net = optim.Adam(net.tgt_net.parameters(), lr=lr, \\n weight_decay=weight_decay, betas=betas)\\n opt_dis = optim.Adam(net.discriminator.parameters(), lr=lr, \\n weight_decay=weight_decay, betas=betas)\\n opt_selector = optim.Adam(net.fc_selector.parameters(), lr=lr*0.1, \\n weight_decay=weight_decay, betas=betas)\\n opt_classifier = optim.Adam(net.classifier.parameters(), lr=lr*0.1, \\n weight_decay=weight_decay, betas=betas)\\n\\n ##############\\n # Train mann #\\n ##############\\n for epoch in range(num_epoch):\\n err = train_epoch(train_src_data, train_tgt_data, net, opt_net, opt_dis, opt_selector, opt_classifier, epoch) \\n if err == -1:\\n print(\\\"No suitable discriminator\\\")\\n break\\n \\n ##############\\n # Save Model #\\n ##############\\n os.makedirs(outdir, exist_ok=True)\\n outfile = join(outdir, 'mann_{:s}_net_{:s}_{:s}.pth'.format(base_model, src, tgt))\\n print('Saving to', outfile)\\n net.save(outfile)\",\n \"def normal(command_strn):\\n return Cmd('execute \\\"normal! {}\\\"'.format(command_strn))\",\n \"def mobilenetv1(**kwargs):\\n return MobileNet(**kwargs)\",\n \"def build_command(args, parser):\\n cmd = \\\"ipmitool -I lanplus\\\"\\n if not args.host:\\n print \\\"\\\\nERROR: hostname is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -H ' + args.host\\n if args.port:\\n cmd += ' -p ' + args.port\\n if not args.user:\\n print \\\"\\\\nERROR: username is required.\\\\n\\\"\\n parser.print_help()\\n sys.exit(1)\\n else:\\n cmd += ' -U ' + args.user\\n if args.passwd:\\n cmd += ' -P ' + args.passwd\\n cmd += ' dcmi power reading'\\n if args.interval:\\n global INTERVAL\\n INTERVAL = args.interval\\n if args.nread:\\n global NREAD\\n NREAD = args.nread\\n else:\\n global INFINITY\\n INFINITY = True\\n if args.store:\\n global STORE\\n STORE = True\\n return cmd\",\n \"def launch_builtin_module(cmd, args):\\n\\n launch_path = \\\"%s/core/cmds/%s.py\\\" % (utils.get_pydtf_dir(), cmd)\\n\\n return __launch_python_module(launch_path, cmd, args)\",\n \"def send_to_ml(obj, ml_name: str):\\n base.send_to_ml(obj, ml_name)\",\n \"def _command(f, wrapper, syntax, namespace, internal=False):\\n logger.info('command : syntax : {0}'.format(syntax))\\n node = Tree.fnode(f, wrapper)\\n node.command.syntax = syntax\\n node.command.internal = internal\\n if namespace:\\n Tree().rename_node(node.name, '{0}.{1}'.format(namespace, f.__qualname__))\\n node.command.build_command_parsing_tree()\",\n \"def test_matmul_vm(self):\\n self.check_dot_vm(matmul_usecase, None, \\\"'@'\\\")\",\n \"def _DefaultLN(self, name):\\n p = self.params\\n return p.layernorm_tpl.Copy().Set(\\n name=name,\\n input_dim=p.model_dim,\\n use_fused_layernorm=p.use_fused_layernorm,\\n fprop_dtype=p.fprop_dtype)\",\n \"def set_label(self):\\n try:\\n self.get_mask()\\n except ex.excError:\\n pass\\n self.label = \\\"netns %s %s/%s %s@%s\\\" % (self.mode, self.ipname, to_cidr(self.mask), self.ipdev, self.container_rid)\",\n \"def command_(self, name):\\n def decorator(func):\\n func.__name__ = name\\n return self.command(func)\\n return decorator\",\n \"def interpret_nl(nl_string):\\n if nl_string == 'relu':\\n return tf.nn.relu\\n elif nl_string == 'sigmoid':\\n return tf.sigmoid\\n elif nl_string == 'tanh':\\n return tf.tanh\\n else:\\n raise NotImplementedError(nl_string)\",\n \"def macro_network():\\n # fmt: off\\n tpm = np.array([\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 1.0, 1.0],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 1.0, 1.0],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 0.3, 0.3],\\n [0.3, 0.3, 1.0, 1.0],\\n [1.0, 1.0, 0.3, 0.3],\\n [1.0, 1.0, 0.3, 0.3],\\n [1.0, 1.0, 0.3, 0.3],\\n [1.0, 1.0, 1.0, 1.0],\\n ])\\n # fmt: on\\n return Network(tpm, node_labels=LABELS[:tpm.shape[1]])\",\n \"def sendMulticast(command):\\n _sendMulticast(command)\",\n \"def test_rename_to_mlflow(mlflow):\\n atom = ATOMClassifier(X_bin, y_bin, experiment=\\\"test\\\", random_state=1)\\n atom.run(\\\"GNB\\\")\\n atom.scoring()\\n assert mlflow.call_count == 10 # 9 from scoring + 1 from training\",\n \"def mod_command(server, output):\\n for target in output.message.split()[1:]:\\n if target in server.ops:\\n server.tell(output.name, '%s is an operator' % (target))\\n continue\\n if target in server.mods:\\n server.tell(output.name, '%s is already a mod' % (target))\\n else:\\n server.mod(output, target)\\n return\",\n \"def __init__(self, *args):\\n _snap.TMMNet_swiginit(self, _snap.new_TMMNet(*args))\",\n \"def make_command(infile, *fns):\\n fnargs = [measure_arg(fn) for fn in fns]\\n return [lm_cmd] + fnargs + [infile]\",\n \"def __init__(self, *args):\\n _snap.TMMNetModeNetI_swiginit(self, _snap.new_TMMNetModeNetI(*args))\",\n \"def make(self):\\n\\n return 'nmake'\",\n \"def export_mlp(self):\\n return self.net\",\n \"def cmd_mdtm(args):\",\n \"def register_command(self, func):\\n self.commands[func.__name__] = func\",\n \"def managed_network_name(self) -> pulumi.Input[str]:\\n return pulumi.get(self, \\\"managed_network_name\\\")\",\n \"def get_net(self,netname, mol = False):\\n lines = self.mfp.get_net(netname)\\n return lines\",\n \"def define_command(self, name, command):\\n code = (\\\"function %s {\\\"\\n \\\" %s \\\\\\\"$@\\\\\\\"\\\\n\\\"\\n \\\"}\\\") % (name, command)\\n self._printer(code)\",\n \"def _llm_type(self) -> str:\\n return \\\"llama.cpp\\\"\",\n \"def setNetmask(self):\\n\\t\\tself.netmask = self.settings.getKeyValue('netmask')\\n\\t\\tself.socket.send('setenv netmask ' + self.netmask+'\\\\r', 1)\\n\\t\\treturn None\",\n \"def get_default_MXNet_mode():\\n return MXNET_DEFAULT_MODE\",\n \"def resnet110g4(**kwargs):\\r\\n return ResNet(BasicBlock, 110, groups=4, **kwargs)\",\n \"def magic_ll(self, parameter_s=''):\\n self.magic_lc(parameter_s+' | grep ^l')\",\n \"def getCommand(self, process, step=False, replica=None):\\n replica = replica or self.replica\\n if not replica: raise NAMDWriterError, \\\"Replica not assigned.\\\"\\n\\n if process == 'min':\\n command = S.NAMD_EXE+' min.in &> min.out'\\n return command\\n\\n elif process == 'eq':\\n if not step: return False\\n outname = replica.eqoutfiletemplate.format(step=step, extension='out')\\n command = S.NAMD_EXE+' eq%i.in &> %s'%(step, outname)\\n return command\\n\\n elif process == 'md':\\n if not step: return False\\n\\n mdouttemplate=replica.mdoutfiletemplate.replace('.{extension}','')\\n outname = mdouttemplate.format(step=step)\\n command = S.NAMD_EXE+' %s.in &> %s.out'%(outname, outname)\\n return command\\n\\n else: pass\",\n \"def get_command(self, kword: str):\\n # Step Zero is to make sure that the name does not belong to a REAL command.\\n zero, mod = super().get_command(kword)\\n if zero:\\n return zero, mod\\n\\n # Otherwise, first, ensure that the keyword does in fact exist in the custom list.\\n command = self.config.commands.get(kword, None)\\n if not command:\\n return None, None\\n response = command[\\\"com\\\"]\\n\\n # Build the function to return the response. Note that \\\"self\\\" exists already.\\n async def cmd_custom(args, src, **_):\\n if args:\\n member = self.get_member(src, args[0].strip())\\n tag = member.mention if member else None\\n else:\\n tag = None\\n\\n nsfw = command.get(\\\"nsfw\\\", False)\\n if nsfw and src.channel.id not in self.config.get(\\\"nsfwChannels\\\"):\\n return None\\n\\n # Replace tags where needed.\\n try:\\n output = response.format(\\n self=src.author.name,\\n myID=src.author.id,\\n tag=tag or src.author.mention,\\n )\\n except KeyError:\\n return None\\n else:\\n return output\\n\\n # Specify the docstring and name so that !help will work on this.\\n short = response.replace(\\\"{\\\", \\\"{{\\\").replace(\\\"}\\\", \\\"}}\\\")\\n if len(short) > 80:\\n short = short[:77] + \\\"...\\\"\\n cmd_custom.__doc__ = (\\n \\\"__Custom command__: Return the following text: ```{}```\\\\n\\\\n\\\".format(short)\\n + command.get(\\n \\\"desc\\\",\\n \\\"This is a custom command, so available help text is limited, but at the same time, the command is very simple. All it does is return a string, although the string may include formatting tags for invoker name, invoker ID, and a targeted mention.\\\",\\n )\\n + \\\"\\\\n\\\\nSyntax: `{p}\\\"\\n + kword.lower()\\n + (\\\" <user_ID>\\\" if \\\"{tag}\\\" in response else \\\"\\\")\\n + \\\"`\\\"\\n )\\n cmd_custom.__name__ = \\\"cmd_\\\" + kword.lower()\\n\\n return cmd_custom, None\",\n \"def simple_net(**kwargs):\\n model = SimpleNet(BasicBlock, [1, 2, 1, 1, 1], [64]*5, **kwargs)\\n return model\",\n \"def model_fn(model_dir):\\n\\n net = gluon.nn.SymbolBlock.imports('%s/model.json' % model_dir,\\n ['data'], \\n param_file='%s/model.params' % model_dir,\\n ctx=mx.cpu())\\n\\n return net\",\n \"def graph_cmd(args):\\n\\n # charge graphviz\\n Digraph = load_graphviz()\\n\\n view = True\\n for i in args:\\n if i == \\\"noview\\\":\\n view = False\\n args.remove(i)\\n break\\n\\n if len(args) > 0:\\n if len(args) >= 2:\\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \\\"traverse\\\":args[1], \\\"mibs\\\":\\\"base\\\" })\\n else:\\n r = requete('NeMo.Intf.%s:getMIBs' % args[0], { \\\"mibs\\\":\\\"base\\\" })\\n else:\\n r = requete('NeMo.Intf.lo:getMIBs', { \\\"traverse\\\":\\\"all\\\", \\\"mibs\\\":\\\"base\\\" })\\n if r is None: return\\n if not 'status' in r or not 'base' in r['status']: return\\n r = r['status']['base']\\n\\n dot = Digraph(name='NeMo.Intf', format='svg', engine='dot')\\n\\n dot.attr('node', fontname='Helvetica')\\n #dot.attr('node', fontname='Times-Roman')\\n\\n for i, node in r.items():\\n #dot.attr('node', tooltip=v['Flags'] if 'Flags' in v else '')\\n if 'Enable' in node:\\n if node['Enable'] == True:\\n dot.node(i, shape='box')\\n else:\\n dot.node(i, shape='ellipse', color='lightgrey')\\n else:\\n dot.node(i, shape='box', color='lightgrey')\\n\\n for i, v in r.items():\\n for j in v['LLIntf']:\\n dot.edge(i, j)\\n\\n dot.render(filename=\\\"nemo_intf.gv\\\", view=view)\",\n \"def test_macro(self):\\n with Graph('g') as graph:\\n a = pike.placeholder()\\n m = graph.macro(a)\\n g1 = m(ParrotNode('foo'))\\n g2 = m(ParrotNode('bar'))\\n self.assertEqual(g1.run(), {'default': 'foo'})\\n self.assertEqual(g2.run(), {'default': 'bar'})\",\n \"def cmd(self):\",\n \"def run_ntcontribs(args):\\n nt_map(args)\",\n \"def nameCommand(*args, annotation: AnyStr=\\\"\\\", command: Script=None, data1: AnyStr=\\\"\\\", data2:\\n AnyStr=\\\"\\\", data3: AnyStr=\\\"\\\", default: bool=True, sourceType: AnyStr=\\\"\\\",\\n **kwargs)->AnyStr:\\n pass\",\n \"def set_net_control(self, net_control: list) -> str:\\n if not net_control:\\n return\\n net_control_list = \\\"\\\"\\n for host in net_control[1:]:\\n net_control_list += host[\\\"hostName\\\"] + \\\"\\\\r\\\" + host[\\\"mac\\\"] + \\\\\\n \\\"\\\\r\\\" + host[\\\"limitUp\\\"] + \\\"\\\\r\\\" + host[\\\"limitDown\\\"] + \\\"\\\\n\\\"\\n return self._req_post(self._URLS['SetNetControl'], data={\\\"list\\\": net_control_list})\",\n \"def do_nmap__Auxilary(self, param):\\n if self.which(\\\"nmap\\\"):\\n self.do_shell(\\\"nmap \\\" + param)\",\n \"def resnet110g8(**kwargs):\\r\\n return ResNet(BasicBlock, 110, groups=8, **kwargs)\",\n \"def netlogo_args():\\n return {\\n \\\"model\\\": \\\"/home/smitty/proj/css600transp/css600transp/FireSim.nlogo\\\",\\n \\\"setup-file\\\": \\\"setup-file.xml\\\",\\n \\\"experiment\\\": \\\"FireSim\\\",\\n \\\"threads\\\": \\\"1\\\",\\n \\\"table\\\": \\\"-\\\",\\n }\",\n \"def makeLabel(self, cmd):\\n if cmd.type in ['Function', 'Call']:\\n return cmd.arg1\\n\\n if self.current_function_name is not None:\\n prefix = self.current_function_name\\n else:\\n prefix = self.ns\\n return prefix + '$' + cmd.arg1\",\n \"def comando_nfce(self):\\r\\n return self.template_nfce()\",\n \"def mgcNetArch(self, **kwargs):\\n\\n def_vals = {\\\"input_img_rows\\\" : self.input_img_rows,\\n \\\"input_img_cols\\\" : self.input_img_cols,\\n \\\"channels\\\" : self.channels,\\n \\\"nb_classes\\\" : self.nb_classes,\\n \\\"outLayer\\\" : 'gloAvg', \\n \\\"l2_val\\\" : 0.00, \\n \\\"net_architr\\\" : 'cnn_max', \\n \\\"block_typex\\\" : 'basic', \\n \\\"block_repeatx\\\" : [1, 1]\\n }\\n\\n\\n for k, v in def_vals.items():\\n kwargs.setdefault(k, v)\\n\\n _input_img_rows = kwargs['input_img_rows']\\n _input_img_cols = kwargs['input_img_cols']\\n _channels = kwargs['channels']\\n _nb_classes = kwargs['nb_classes']\\n _outLayer = kwargs['outLayer']\\n _l2_val = kwargs['l2_val']\\n _net_architr = kwargs['net_architr']\\n _block_typex = kwargs['block_typex']\\n _block_repeatx = kwargs['block_repeatx']\\n \\n \\n params = {\\\"input_img_rows\\\" : _input_img_rows,\\n \\\"input_img_cols\\\" : _input_img_cols,\\n \\\"channels\\\" : _channels,\\n \\\"nb_classes\\\" : _nb_classes\\n }\\n \\n print(_net_architr)\\n if _net_architr == 'cnn_max':\\n model = mgcNetArchMax(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'cnn_stride':\\n model = mgcNetArchStride2(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'cnn_stride_mini':\\n model = mgcNetArchStride2Mini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'common_cnn':\\n model = mgcNetArchCommonCnn(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'net_in_net':\\n model = mgcNetArchNin(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n elif _net_architr == 'resnet':\\n model = mgcResnet(block_type = _block_typex, block_repeat = _block_repeatx, **params)\\n \\n elif _net_architr == 'resblock':\\n model = mgcNetArchRes(outLayer = _outLayer, l2_val = _l2_val, **params)\\n\\n elif _net_architr == 'skipconnect':\\n model = mgcNetArchSkip(outLayer = _outLayer, l2_val = _l2_val, **params)\\n elif _net_architr == 'skipconnect_mini':\\n model = mgcNetArchSkipMini(outLayer = _outLayer, l2_val = _l2_val, **params)\\n \\n self.model = model\\n self.plot_model = SVG(model_to_dot(model, show_shapes = True).create(prog='dot', format='svg'))\\n #self.model_summary = model.summary() \\n \\n return self\",\n \"def niw_mmml(X, lambda_0, mu_0, kappa_0, nu_0, crp_alpha, Z_start, k_start,\\n hist_start, ncalc):\\n ml = lgniwmmml(X, lambda_0, mu_0, kappa_0, nu_0, crp_alpha, Z_start,\\n k_start, hist_start, ncalc)\\n return ml\",\n \"def brain(msg):\\n\\n def check_message(msg):\\n \\\"\\\"\\\"\\n Check wich neuron to use.\\n :param msg:\\n :return:\\n \\\"\\\"\\\"\\n words_of_message = msg.split()\\n find = False\\n for key in gc_words:\\n if words_of_message in gc_words[key]['groups']:\\n getattr(neuron.general_conversations, key)()\\n find = True\\n break\\n for key in fc_words:\\n if words_of_message in fc_words[key]['groups']:\\n getattr(neuron.forecast, key)()\\n find = True\\n break\\n for key in twitter_words:\\n if words_of_message in twitter_words[key]['groups']:\\n getattr(neuron.twitter, key)()\\n find = True\\n break\\n for key in pipo_words:\\n if words_of_message in pipo_words[key]['groups']:\\n getattr(neuron.pipotron, key)()\\n find = True\\n break\\n if not find:\\n neuron.general_conversations.undefined()\\n\\n check_message(msg)\",\n \"def command(fxn):\\n\\tCMDTABLE[fxn.__name__] = (fxn, fxn.__doc__)\\n\\treturn fxn\",\n \"def resnet34(**kwargs):\\n model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)\\n return model\",\n \"def main_net_args(parser, allowed_nets=['fc'], dfc_arch='100,100',\\n dmlp_arch='100,100', show_net_act=True, dnet_act='relu',\\n show_no_bias=False, show_dropout_rate=True,\\n ddropout_rate=-1, show_specnorm=True, show_batchnorm=True,\\n show_no_batchnorm=False, show_bn_no_running_stats=False,\\n show_bn_distill_stats=False,\\n show_bn_no_stats_checkpointing=False,\\n prefix=None, pf_name=None):\\n assert(prefix is None or pf_name is not None)\\n\\n # TODO Delete 'fc' from list.\\n for nt in allowed_nets:\\n assert(nt in ['fc', 'mlp', 'resnet', 'zenke', 'bio_conv_net'])\\n\\n assert(not show_batchnorm or not show_no_batchnorm)\\n\\n # TODO 'fc' should be renamed to 'mlp'.\\n if 'fc' in allowed_nets and len(allowed_nets) == 1:\\n warn('Network type \\\"fc\\\" is deprecated. Default value of argument ' +\\n '\\\"allowed_nets\\\" will be changed to [\\\\'mlp\\\\'] in the future!',\\n DeprecationWarning)\\n elif 'fc' in allowed_nets:\\n # TODO change warning into error at some point.\\n warn('Network type \\\"fc\\\" is deprecated! Use \\\"mlp\\\" instead.',\\n DeprecationWarning)\\n if 'fc' in allowed_nets and 'mlp' in allowed_nets:\\n # Doesn't make sense to have both.\\n raise ValueError('Network type names \\\"fc\\\" and \\\"mlp\\\" refer to the ' +\\n 'same network type! Note, \\\"fc\\\" is deprecated.')\\n\\n heading = 'Main network options'\\n\\n if prefix is None:\\n prefix = ''\\n pf_name = ''\\n else:\\n heading = 'Main network options for %s network' % pf_name\\n pf_name += ' '\\n\\n # Abbreviations.\\n p = prefix\\n n = pf_name\\n\\n ### Main network options.\\n agroup = parser.add_argument_group(heading)\\n\\n if len(allowed_nets) > 1:\\n agroup.add_argument('--%snet_type' % p, type=str,\\n default=allowed_nets[0],\\n help='Type of network to be used for this %s ' % n +\\n 'network. Default: %(default)s.',\\n choices=allowed_nets)\\n\\n # DELETEME once we delete option 'fc'.\\n if 'fc' in allowed_nets:\\n agroup.add_argument('--%sfc_arch' % p, type=str, default=dfc_arch,\\n help='If using a \\\"fc\\\" %s network, this will ' % n +\\n 'specify the hidden layers. ' +\\n 'Default: %(default)s.')\\n\\n if 'mlp' in allowed_nets:\\n agroup.add_argument('--%smlp_arch' % p, type=str, default=dmlp_arch,\\n help='If using a \\\"mlp\\\" %s network, this will ' % n +\\n 'specify the hidden layers. ' +\\n 'Default: %(default)s.')\\n\\n # Note, if you want to add more activation function choices here, you have\\n # to add them to the corresponding function `utils.misc.str_to_act` as well!\\n if show_net_act:\\n agroup.add_argument('--%snet_act' % p, type=str, default=dnet_act,\\n help='Activation function used in the %s network.' % n +\\n 'If \\\"linear\\\", no activation function is used. ' +\\n 'Default: %(default)s.',\\n choices=['linear', 'sigmoid', 'relu', 'elu'])\\n\\n if show_no_bias:\\n agroup.add_argument('--%sno_bias' % p, action='store_true',\\n help='No biases will be used in the %s network. ' % n +\\n 'Note, does not affect normalization (like ' +\\n 'batchnorm).')\\n\\n if show_dropout_rate:\\n agroup.add_argument('--%sdropout_rate' % p, type=float,\\n default=ddropout_rate,\\n help='Use dropout in the %s network with the ' % n +\\n 'given dropout probability (dropout is ' +\\n 'deactivated for a rate of -1). Default: ' +\\n '%(default)s.')\\n\\n if show_specnorm:\\n agroup.add_argument('--%sspecnorm' % p, action='store_true',\\n help='Enable spectral normalization in the ' +\\n '%s network.' % n)\\n\\n ### Batchnorm related options.\\n if show_batchnorm:\\n agroup.add_argument('--%sbatchnorm' % p, action='store_true',\\n help='Enable batchnorm in the %s network.' % n)\\n if show_no_batchnorm:\\n agroup.add_argument('--%sno_batchnorm' % p, action='store_true',\\n help='Disable batchnorm in the %s network.' % n)\\n\\n if show_bn_no_running_stats:\\n agroup.add_argument('--%sbn_no_running_stats' % p, action='store_true',\\n help='If batch normalization is used, then this ' +\\n 'option will deactivate the tracking ' +\\n 'of running statistics. Hence, statistics ' +\\n 'computed per batch will be used during ' +\\n 'evaluation.')\\n\\n if show_bn_distill_stats:\\n agroup.add_argument('--%sbn_distill_stats' % p, action='store_true',\\n help='If batch normalization is used, ' +\\n 'then usually the running statistics are ' +\\n 'checkpointed for every task (e.g., in ' +\\n 'continual learning), which has linearly ' +\\n 'increasing memory requirements. If ' +\\n 'this option is activated, the running ' +\\n 'statistics will be distilled into the ' +\\n 'hypernetwork after training each task, ' +\\n 'such that only the statistics of the ' +\\n 'current and previous task have to be ' +\\n 'explicitly kept in memory')\\n\\n if show_bn_no_stats_checkpointing:\\n agroup.add_argument('--%sbn_no_stats_checkpointing' % p,\\n action='store_true',\\n help='If batch normalization is used, then' +\\n 'this option will prevent the checkpointing' +\\n 'of batchnorm statistics for every task.' +\\n 'In this case, one set of statistics is ' +\\n 'used for all tasks.')\\n\\n return agroup\",\n \"def make_mlp_likelihood_rlssm(\\n model=None, model_config=None, model_config_rl=None, wiener_params=None, **kwargs\\n):\\n\\n def make_likelihood():\\n likelihood_str = make_likelihood_str_mlp_rlssm(\\n model=model,\\n config=model_config,\\n config_rl=model_config_rl,\\n wiener_params=wiener_params,\\n )\\n exec(likelihood_str)\\n my_fun = locals()[\\\"custom_likelihood\\\"]\\n return my_fun\\n\\n likelihood_ = make_likelihood()\\n\\n wfpt_nn_rl = stochastic_from_dist(\\n \\\"WienernnRL_\\\" + model, partial(likelihood_, **kwargs)\\n )\\n\\n return wfpt_nn_rl\",\n \"def test_matmul_mm(self):\\n self.check_dot_mm(matmul_usecase, None, \\\"'@'\\\")\",\n \"def _llm_type(self) -> str:\\n return \\\"openai\\\"\",\n \"def set_model_gripper_command(robot,limb,command):\\n qrobot = robot.getConfig()\\n qhand = gripper.commandToConfig(command)\\n if limb=='left':\\n print \\\"Opening left gripper to\\\",command\\n for i in range(gripper.numDofs):\\n qrobot[left_hand_link_start+i] = qhand[i]\\n # else:\\n # print \\\"Opening right gripper to\\\",command\\n # for i in range(gripper.numDofs):\\n # qrobot[right_hand_link_start+i] = qhand[i]\\n robot.setConfig(qrobot)\",\n \"def but_load_net(self):\\n a = tk.filedialog.askopenfilename(filetypes = [('NN file',['*.csv','*.pt'])])\\n self.nn_obj=load_nn(a)\",\n \"def expose_magic(magicname, func):\\n \\n from IPython import Magic\\n import new\\n im = new.instancemethod(func,__IP, __IP.__class__)\\n setattr(__IP, \\\"magic_\\\" + magicname, im)\",\n \"def type_command(ctx, name_from, name_to):\",\n \"def mobilenet(path = \\\"\\\"):\\n lr='0.0005'\\n model = create_mobilenet(48, 0.5)\\n layer_name=[]\\n files = os.listdir(path)\\n for layer in model.layers:\\n check = path + \\\"/\\\" + layer.name + \\\".png\\\"\\n if check in [path+'/'+f for f in files]:\\n if 'conv' in layer.name and (not 'bn' in layer.name) and (not 'pad' in layer.name) and (not 'relu' in layer.name):\\n layer_name.append([check,[layer.name ,str(layer.kernel_size[0]) + ' x ' + str(layer.kernel_size[1]), '-']])\\n else:\\n layer_name.append([check,[layer.name,'-', '-']])\\n return layer_name\",\n \"def makecmd(self, options):\",\n \"def resnet18(**kwargs):\\n model = ResNet(BasicBlock, [2, 2, 2, 2], **kwargs)\\n return model\",\n \"def ResNetLN18(num_classes=10):\\n return ResNet(BasicLNBlock, \\n [2, 2, 2, 2], \\n num_classes=num_classes,\\n norm_type=\\\"LN\\\")\",\n \"def intf_MMLIST(E):\\n print(MMEL.__repr__())\\n #print(OUT.default(MMEL,E))\",\n \"def resnet34(**kwargs):\\n model = ResNet(BasicBlock, [3, 4, 6, 3], **kwargs)\\n\\n return model\",\n \"def lt_command(self):\\n self.write(\\n \\\"@SP\\\\nA=M-1\\\\nD=M\\\\n@NEG1\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JLT\\\\n@POS1\\\" + str(\\n self.__label_num) +\\n \\\"\\\\nD;JGE\\\\n(NEG1\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nA=A-1\\\\nD=M\\\\n@POS2\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JGT\\\\n@CONT\\\"\\n + str(self.__label_num) + \\\"\\\\n0;JMP\\\\n(POS1\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nA=A-1\\\\nD=M\\\\n@NEG2\\\" +\\n str(self.__label_num) + \\\"\\\\nD;JLT\\\\n@CONT\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(POS2\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\"\\n \\\"\\\\nA=M-1\\\\nA=A-1\\\\nM=0\\\\n@SP\\\\nM=M-1\\\\n@ENDLABEL\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(NEG2\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\" +\\n \\\"\\\\nA=M-1\\\\nA=A-1\\\\nM=-1\\\\n@SP\\\\nM=M-1\\\\n@ENDLABEL\\\" + str(\\n self.__label_num) + \\\"\\\\n0;JMP\\\\n(CONT\\\" + str(\\n self.__label_num) + \\\")\\\\n\\\"\\n \\\"@SP\\\\nM=M-1\\\\nA=M\\\\nD=M\\\\n@SP\\\\nA=M-1\\\\nD=M-D\\\\n@TRUE\\\" + str(\\n self.__label_num) + \\\"\\\\nD;JGE\\\\n@SP\\\\nA=M-1\\\\nM=-1\\\\n@ENDLABEL\\\" +\\n str(self.__label_num) + \\\"\\\\n0;JMP\\\\n(TRUE\\\" + str(\\n self.__label_num) + \\\")\\\\n@SP\\\\nA=M-1\\\\nM=0\\\\n(ENDLABEL\\\" +\\n str(self.__label_num) + \\\")\\\\n\\\")\",\n \"def __getattr__(self, cmd):\\n\\n if hasattr(self._rpc, cmd+'Request'):\\n lnfunc = getattr(self._rpc, cmd+'Request')\\n elif hasattr(self._rpc, f'Get{cmd}Request'):\\n lnfunc = getattr(self._rpc, f'Get{cmd}Request')\\n else:\\n raise NotImplementedError('Unhandled method self._rpc.(Get)' + cmd + 'Request')\\n\\n if hasattr(self._stub, cmd):\\n stubfunc = getattr(self._stub, cmd)\\n\\n def rpcCommand(*args,**kwargs):\\n return stubfunc(lnfunc(*args, **kwargs))\\n return rpcCommand\\n\\n elif hasattr(self._stub, 'Get'+cmd):\\n stubfunc = getattr(self._stub, 'Get'+cmd)\\n def rpcCommand(*args,**kwargs):\\n if args:\\n raise TypeError('Cannot use positional arguments with this command')\\n return stubfunc(lnfunc(**kwargs))\\n return rpcCommand\\n\\n else:\\n raise NotImplementedError('Unhandled method stub.(Get)' + cmd)\",\n \"def command():\\n pass\",\n \"def parse_args():\\n parser = argparse.ArgumentParser(description='MXNet Gluon Semantic Segmentation')\\n # model and dataset\\n parser.add_argument('--model', type=str, default='fcn',\\n help='model name (default: fcn)')\\n parser.add_argument('--model-zoo', type=str, default=None,\\n help='evaluating on model zoo model')\\n parser.add_argument('--pretrained', action=\\\"store_true\\\",\\n help='whether to use pretrained params')\\n parser.add_argument('--backbone', type=str, default='resnet50',\\n help='backbone name (default: resnet50)')\\n parser.add_argument('--dataset', type=str, default='pascal',\\n help='dataset name (default: pascal)')\\n parser.add_argument('--workers', type=int, default=16,\\n metavar='N', help='dataloader threads')\\n parser.add_argument('--base-size', type=int, default=520,\\n help='base image size')\\n parser.add_argument('--crop-size', type=int, default=480,\\n help='crop image size')\\n parser.add_argument('--train-split', type=str, default='train',\\n help='dataset train split (default: train)')\\n # training hyper params\\n parser.add_argument('--aux', action='store_true', default=False,\\n help='Auxiliary loss')\\n parser.add_argument('--aux-weight', type=float, default=0.5,\\n help='auxiliary loss weight')\\n parser.add_argument('--epochs', type=int, default=50, metavar='N',\\n help='number of epochs to train (default: 50)')\\n parser.add_argument('--start_epoch', type=int, default=0,\\n metavar='N', help='start epochs (default:0)')\\n parser.add_argument('--batch-size', type=int, default=16,\\n metavar='N', help='input batch size for \\\\\\n training (default: 16)')\\n parser.add_argument('--test-batch-size', type=int, default=16,\\n metavar='N', help='input batch size for \\\\\\n testing (default: 16)')\\n parser.add_argument('--optimizer', type=str, default='sgd',\\n help='optimizer (default: sgd)')\\n parser.add_argument('--lr', type=float, default=1e-3, metavar='LR',\\n help='learning rate (default: 1e-3)')\\n parser.add_argument('--warmup-epochs', type=int, default=0,\\n help='number of warmup epochs.')\\n parser.add_argument('--momentum', type=float, default=0.9,\\n metavar='M', help='momentum (default: 0.9)')\\n parser.add_argument('--weight-decay', type=float, default=1e-4,\\n metavar='M', help='w-decay (default: 1e-4)')\\n parser.add_argument('--no-wd', action='store_true',\\n help='whether to remove weight decay on bias, \\\\\\n and beta/gamma for batchnorm layers.')\\n parser.add_argument('--mode', type=str, default=None,\\n help='whether to turn on model hybridization')\\n # cuda and distribute\\n parser.add_argument('--no-cuda', action='store_true', default=False,\\n help='disables CUDA training')\\n parser.add_argument('--ngpus', type=int,\\n default=len(mx.test_utils.list_gpus()),\\n help='number of GPUs (default: 4)')\\n parser.add_argument('--kvstore', type=str, default='device',\\n help='kvstore to use for trainer/module.')\\n parser.add_argument('--dtype', type=str, default='float32',\\n help='data type for training. default is float32')\\n # checking point\\n parser.add_argument('--resume', type=str, default=None,\\n help='put the path to resuming file if needed')\\n parser.add_argument('--checkname', type=str, default='default',\\n help='set the checkpoint name')\\n parser.add_argument('--save-dir', type=str, default=None,\\n help='directory of saved models')\\n parser.add_argument('--log-interval', type=int, default=20,\\n help='Number of batches to wait before logging.')\\n parser.add_argument('--logging-file', type=str, default='train.log',\\n help='name of training log file')\\n # evaluation only\\n parser.add_argument('--eval', action='store_true', default=False,\\n help='evaluation only')\\n parser.add_argument('--no-val', action='store_true', default=False,\\n help='skip validation during training')\\n # synchronized Batch Normalization\\n parser.add_argument('--syncbn', action='store_true', default=False,\\n help='using Synchronized Cross-GPU BatchNorm')\\n # the parser\\n args = parser.parse_args()\\n\\n # handle contexts\\n if args.no_cuda:\\n print('Using CPU')\\n args.kvstore = 'local'\\n args.ctx = [mx.cpu(0)]\\n else:\\n print('Number of GPUs:', args.ngpus)\\n assert args.ngpus > 0, 'No GPUs found, please enable --no-cuda for CPU mode.'\\n args.ctx = [mx.gpu(i) for i in range(args.ngpus)]\\n\\n if 'psp' in args.model or 'deeplab' in args.model:\\n assert args.crop_size % 8 == 0, ('For PSPNet and DeepLabV3 model families, '\\n 'we only support input crop size as multiples of 8.')\\n\\n # logging and checkpoint saving\\n if args.save_dir is None:\\n args.save_dir = \\\"runs/%s/%s/%s/\\\" % (args.dataset, args.model, args.backbone)\\n makedirs(args.save_dir)\\n\\n # Synchronized BatchNorm\\n args.norm_layer = mx.gluon.contrib.nn.SyncBatchNorm if args.syncbn \\\\\\n else mx.gluon.nn.BatchNorm\\n args.norm_kwargs = {'num_devices': args.ngpus} if args.syncbn else {}\\n return args\",\n \"def setNetmask(self, netmask):\\n # type: (str)->None\\n\\n self._validator.validate_one(\\n 'netmask', VALID_OPTS['netmask'], netmask)\\n self._ifAttributes['netmask'] = netmask\",\n \"def add(self, name, command):\",\n \"def ReadNet(model_def):\\n with open(model_def) as f:\\n net = cp.NetParameter()\\n pb.text_format.Parse(f.read(), net)\\n return net\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6607906","0.5527357","0.54824287","0.5431624","0.54184914","0.54072374","0.53655416","0.52886176","0.5091649","0.49965236","0.4974869","0.49429768","0.49062353","0.48281196","0.48139057","0.4807876","0.47813764","0.47685274","0.47484493","0.47436157","0.47424507","0.4737015","0.47182307","0.46940708","0.46901074","0.4607513","0.46017912","0.45931214","0.45905006","0.45865294","0.45719948","0.45618552","0.45519516","0.45431393","0.45360467","0.45344853","0.4519848","0.45078346","0.45041546","0.4503523","0.4492923","0.44811898","0.44698638","0.44663948","0.44653895","0.4464974","0.44638208","0.44572476","0.4450622","0.44446406","0.44290233","0.4426077","0.44078755","0.44046882","0.44035232","0.43929294","0.43901703","0.4389496","0.43859267","0.43829024","0.43768847","0.43767095","0.43622556","0.43611467","0.43603122","0.4345327","0.4344958","0.43414855","0.43395787","0.4339417","0.43367872","0.43353376","0.43314072","0.43289593","0.43249547","0.43243843","0.43129432","0.4310898","0.4307347","0.43067682","0.43048018","0.43035108","0.4303062","0.43009564","0.42943048","0.42857227","0.4281816","0.42809457","0.42770728","0.42743194","0.42723694","0.4269986","0.42690313","0.4260747","0.42567918","0.4255237","0.42547533","0.42514908","0.42497787","0.42486528"],"string":"[\n \"0.6607906\",\n \"0.5527357\",\n \"0.54824287\",\n \"0.5431624\",\n \"0.54184914\",\n \"0.54072374\",\n \"0.53655416\",\n \"0.52886176\",\n \"0.5091649\",\n \"0.49965236\",\n \"0.4974869\",\n \"0.49429768\",\n \"0.49062353\",\n \"0.48281196\",\n \"0.48139057\",\n \"0.4807876\",\n \"0.47813764\",\n \"0.47685274\",\n \"0.47484493\",\n \"0.47436157\",\n \"0.47424507\",\n \"0.4737015\",\n \"0.47182307\",\n \"0.46940708\",\n \"0.46901074\",\n \"0.4607513\",\n \"0.46017912\",\n \"0.45931214\",\n \"0.45905006\",\n \"0.45865294\",\n \"0.45719948\",\n \"0.45618552\",\n \"0.45519516\",\n \"0.45431393\",\n \"0.45360467\",\n \"0.45344853\",\n \"0.4519848\",\n \"0.45078346\",\n \"0.45041546\",\n \"0.4503523\",\n \"0.4492923\",\n \"0.44811898\",\n \"0.44698638\",\n \"0.44663948\",\n \"0.44653895\",\n \"0.4464974\",\n \"0.44638208\",\n \"0.44572476\",\n \"0.4450622\",\n \"0.44446406\",\n \"0.44290233\",\n \"0.4426077\",\n \"0.44078755\",\n \"0.44046882\",\n \"0.44035232\",\n \"0.43929294\",\n \"0.43901703\",\n \"0.4389496\",\n \"0.43859267\",\n \"0.43829024\",\n \"0.43768847\",\n \"0.43767095\",\n \"0.43622556\",\n \"0.43611467\",\n \"0.43603122\",\n \"0.4345327\",\n \"0.4344958\",\n \"0.43414855\",\n \"0.43395787\",\n \"0.4339417\",\n \"0.43367872\",\n \"0.43353376\",\n \"0.43314072\",\n \"0.43289593\",\n \"0.43249547\",\n \"0.43243843\",\n \"0.43129432\",\n \"0.4310898\",\n \"0.4307347\",\n \"0.43067682\",\n \"0.43048018\",\n \"0.43035108\",\n \"0.4303062\",\n \"0.43009564\",\n \"0.42943048\",\n \"0.42857227\",\n \"0.4281816\",\n \"0.42809457\",\n \"0.42770728\",\n \"0.42743194\",\n \"0.42723694\",\n \"0.4269986\",\n \"0.42690313\",\n \"0.4260747\",\n \"0.42567918\",\n \"0.4255237\",\n \"0.42547533\",\n \"0.42514908\",\n \"0.42497787\",\n \"0.42486528\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5684712"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20187,"cells":{"query":{"kind":"string","value":"Normalize a ND numpy array along the specified axis."},"document":{"kind":"string","value":"def normalize(nparray, order=2, axis=0):\n norm = np.linalg.norm(nparray, ord=order, axis=axis, keepdims=True)\n return nparray / (norm + np.finfo(np.float32).eps)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def normalize(a, axis=None):\n a_sum = a.sum(axis)\n if axis and a.ndim > 1:\n a_sum[a_sum == 0] = 1\n shape = list(a.shape)\n shape[axis] = 1\n a_sum.shape = shape\n\n return a / a_sum","def normalize_axis(x, axis, dtype=float):\n x = x.astype(dtype)\n ind_list = [slice(None) for i in range(x.ndim)]\n try:\n for i in range(x.shape[axis]):\n ind_list[axis] = i\n ind = tuple(ind_list)\n minn = x[ind].min()\n maxx = x[ind].max()\n x[ind] = (x[ind]-minn) / (maxx-minn)\n except IndexError:\n raise np.AxisError(\n \"axis {} is out of bounds for array of dimension {}\".format(\n axis, x.ndim\n )\n )\n return x","def normalize(X, norm=..., *, axis=..., copy=..., return_norm=...):\n ...","def normalize(X, axis=-1, order=2):\n l2 = np.atleast_1d(np.linalg.norm(X, order, axis))\n l2[l2 == 0] = 1\n return X / np.expand_dims(l2, axis)","def _normalize(X: np.ndarray) -> np.ndarray:\n # return X * np.sqrt(1 / np.sum(X ** 2, axis=1))[:, None]\n return X * np.sqrt(X.shape[1] / np.sum(X ** 2, axis=1))[:, None]","def normalised(a: np.ndarray, order: int = None, axis: int = -1) -> np.ndarray:\n norm = np.atleast_1d(np.linalg.norm(a, order, axis))\n return a / np.expand_dims(norm, axis)","def normalize_array(array):\n\n return array / np.sum(array, axis=1)[:, np.newaxis]","def normalize(x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalize(x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalize(x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalized(a, axis=-1, order=2):\n l2 = np.atleast_1d(np.linalg.norm(a, order, axis))\n l2[l2==0] = 1\n return a / np.expand_dims(l2, axis)","def normalize(inp):\n\n out = inp / np.linalg.norm(inp, axis=1, keepdims=True)\n\n return out","def normalize(self, x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalise(x, dim=1):\n norm = torch.sqrt( torch.pow(x,2.).sum(dim) )\n if dim>0:\n x /= norm.unsqueeze(dim)\n return x","def image_normalize(im, axis=(0, 1), c=1e-8):\n return (im - im.mean(axis)) / (im.std(axis) + c)","def __normalize_after_fft(arr):\n\n n1, n2 = arr.shape[0], arr.shape[1]\n for i in range(n1):\n for j in range(n2):\n arr[i, j] *= n1 * n2\n\n return arr","def normalize(X):\n\tX = X - np.mean(X,axis=1)[:,np.newaxis]\n\tX = X/np.std(X,axis=0)[np.newaxis,:];\n\tX = X - np.mean(X,axis=0)[np.newaxis,:]\n\treturn X","def normalize(arr, eps):\n\n norm = cuda.reduce('T x', 'T out',\n 'x * x', 'a + b', 'out = sqrt(a)', 0,\n 'norm_sn')(arr)\n cuda.elementwise('T norm, T eps',\n 'T x',\n 'x /= (norm + eps)',\n 'div_sn')(norm, eps, arr)\n return norm","def l2_normalize(data, axis=-1, eps=1e-6):\n ret = data / (np.linalg.norm(data, axis=axis, keepdims=True) + eps)\n return ret","def normalize(array, norm=\"l2\"):\n scaler = Normalizer(copy=True, norm=norm)\n return scaler.fit_transform(array)","def normalise(self):\n return self / self.mean(axis=1).reshape(self.shape[0], 1)","def vector_normalize(vec, axis=None):\n mag = vector_magnitude(vec, axis=axis)\n mag = mag if mag > 0 else 1\n if axis is None:\n return vec / mag\n else:\n axis_ix = [None] * len(vec.shape)\n axis_ix[axis] = slice(None, None, None)\n return vec / numpy.array([mag])[axis_ix]","def _normalize(\n ds: xr.Dataset,\n *,\n dim: Sequence[str],\n kind: str = ADDITIVE,\n) -> xr.Dataset:\n if \"norm\" in ds:\n norm = ds.norm\n else:\n norm = ds.data.mean(dim=dim)\n norm.attrs[\"_group_apply_reshape\"] = True\n\n return xr.Dataset(\n dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm)\n )","def normalize(arr):\n m = np.min(arr)\n arr = arr - m\n M = np.max(arr)\n arr = arr / M\n return arr","def naive_act_norm_initialize(x, axis):\n x = np.asarray(x)\n axis = list(sorted(set([a + len(x.shape) if a < 0 else a for a in axis])))\n min_axis = np.min(axis)\n reduce_axis = tuple(a for a in range(len(x.shape)) if a not in axis)\n var_shape = [x.shape[a] for a in axis]\n var_shape_aligned = [x.shape[a] if a in axis else 1\n for a in range(min_axis, len(x.shape))]\n mean = np.reshape(np.mean(x, axis=reduce_axis), var_shape)\n bias = -mean\n scale = 1. / np.reshape(\n np.sqrt(np.mean((x - np.reshape(mean, var_shape_aligned)) ** 2,\n axis=reduce_axis)),\n var_shape\n )\n return scale, bias, var_shape_aligned","def normalize(tensor: np.ndarray):\n if len(tensor.shape) < 4:\n tensor = np.expand_dims(tensor, axis=2)\n mean = np.array([tensor[..., chn, :].mean() for chn in range(tensor.shape[2])])\n std = np.array([tensor[..., chn, :].std() for chn in range(tensor.shape[2])])\n return (tensor - mean[:, np.newaxis]) / std[:, np.newaxis]","def normalize(x):\n\n x_norm = np.linalg.norm(x, axis=1, keepdims=True)\n print(x_norm)\n x = x / x_norm\n ### END\n\n return x","def normalize(array, inplace=False):\n if inplace:\n array -= ds_mean\n array /= ds_std\n else:\n array = (array - ds_mean) / ds_std\n return array","def _normalize(self, x, axis, eps=1e-5):\n return x / (\n tf.sqrt(tf.reduce_sum(tf.square(x), axis=axis, keep_dims=True)) + 1e-5)","def _scale(x, axis=None):\n x = _remove_baseline(x, axis=axis)\n x /= np.std(x, ddof=1, axis=axis, keepdims=True)\n return x","def normalize(A, normRange, normAxis):\n\n shape = A.shape\n # make a slice to take the mean in the right dimension\n # slice(None) effectively means ':', or all the elements\n normSlice = [slice(normRange[0], normRange[1]) if a is normAxis else slice(None) for a in range(len(shape))]\n norm = np.mean(A[normSlice], axis=normAxis)\n\n # make a slice to pad the numbers to make the broadcasting work\n # again, slice(None) means ':' and None means an empty dimension (note difference!)\n\n try:\n return A/norm\n except:\n subSlice=[slice(None) if axis == norm.shape[0] else None for axis in shape]\n return A / norm[subSlice]\n finally:\n pass","def normalize(arr: np.ndarray) -> np.ndarray:\n if max(arr) - min(arr) == 0:\n logger.warning(\n \"Normalize averted a div/0, the input data was:\\n {0}\".format(arr)\n )\n return np.ones(len(arr))\n return (arr - min(arr)) / (max(arr) - min(arr))","def normalize(A: np.array) -> np.array:\n for i in range(A.shape[1]):\n A[:, i] = (A[:, i] - np.min(A[:, i])) / (np.max(A[:, i] - np.min(A[:, i])))\n return A","def normalize_data(img):\n nor = np.linalg.norm(img, axis = 1)\n nor = np.reshape(nor, (len(img), 1))\n img = np.divide(img, nor)\n return img","def demean_normalize(one_d_array):\n\n temp_arr = one_d_array - np.nanmean(one_d_array)\n\n return temp_arr/np.nanstd(temp_arr)","def normalize(data):\n data = numpy.asmatrix(data)\n std_devs = numpy.std(data, axis=1)\n std_devs[std_devs == 0] = 1 # prevent div by 0\n return (data - numpy.mean(data, axis=1)) / std_devs","def normalize_data(data=None):\n # Data pre-processing\n n = data.shape[0]\n for i in range(n):\n xx = data[i,:,:]\n xx -= np.mean(xx) # Centering in 0\n xx /= np.linalg.norm(xx) # Normalizing to 1\n data[i] = xx # Affect value\n return data","def _normalize(x):\n tol = 1e-10\n dims = x.shape\n\n x = x.flatten()\n inverse = (np.sum(x**2) + tol) ** -.5\n x = x * inverse\n x = np.reshape(x, dims)\n\n return x","def normalise(x):\n x = np.copy(x)\n n_cols = x.shape[1]\n for col_index in range(n_cols):\n col = x[:, col_index]\n factor = np.max(col)\n x[:, col_index] = col / factor\n\n return x","def normalize_array(arr, method=\"min_max\"):\r\n \r\n ret = torch.tensor(arr)\r\n if method == \"min_max\":\r\n ret -= torch.min(ret)\r\n ret /= torch.max(ret)\r\n elif method == \"mean_std\":\r\n ret -= torch.mean(ret)\r\n ret /= torch.std(ret)\r\n else:\r\n raise Exception(\"Invalid normalization method\")\r\n\r\n return 1 + ret","def _normalize(weights, axis, log=True):\n if log:\n normalizer = tf.reduce_logsumexp(weights, axis=axis, keepdims=True)\n return weights - normalizer\n normalizer = tf.reduce_sum(weights, axis=axis)\n return weights / normalizer","def normalize_data(x):\n mvec = x.mean(0)\n stdvec = x.std(axis=0)\n \n return (x - mvec)/stdvec","def normalize_data(x):\n mvec = x.mean(0)\n stdvec = x.std(axis=0)\n \n return (x - mvec)/stdvec","def standardize(x, axis=-1):\n stds_avg = np.std(x, axis=axis, keepdims=True)\n x -= np.mean(x, axis=axis, keepdims=True)\n x /= (stds_avg + 1e-8)\n return x","def normalize(data):\n row = np.size(data, 0) # number of data points\n col = np.size(data, 1) # dimensionality of data points\n for j in range(col):\n # find the average for each column\n col_sum = 0\n for i in range(row):\n col_sum = col_sum + data[i][j]\n col_sum = col_sum / row\n # subtract the average from each value in the column\n for i in range(row):\n data[i][j] = data[i][j] - col_sum\n return data","def normalize(data):\n row = np.size(data, 0) # number of data points\n col = np.size(data, 1) # dimensionality of data points\n for j in range(col):\n # find the average for each column\n col_sum = 0\n for i in range(row):\n col_sum = col_sum + data[i][j]\n col_sum = col_sum / row\n # subtract the average from each value in the column\n for i in range(row):\n data[i][j] = data[i][j] - col_sum\n return data","def normalize_matrix(matrix, axis=1):\n if len(matrix.shape) == 1:\n # turn vector into matrix with one row\n matrix = matrix[np.newaxis, :]\n divisor = np.linalg.norm(matrix, axis=axis)[:, np.newaxis]\n # only normalize where divisor is not zero\n result = np.divide(matrix, divisor, out=np.zeros(matrix.shape), where=divisor != 0)\n return result","def _normalize_matrix_on_axis(m, axis=0):\n if m.ndim > 2:\n raise ValueError(\n \"This function only accepts 2D arrays. \"\n f\"An array of shape {m.shape:r} was passed.\"\n )\n\n if axis == 0:\n # array transposition preserves the contiguity flag of that array\n ret = (m.T / np.sqrt(np.sum(m**2, axis=0))[:, np.newaxis]).T\n elif axis == 1:\n ret = _normalize_matrix_on_axis(m.T).T\n else:\n raise ValueError(f\"axis(={int(axis)}) out of bounds\")\n return ret","def _normalize(array):\n\treturn (array - np.min(array))/(np.max(array)-np.min(array))","def normalize(v):\n\tdim = v.shape \n\tfor i in range(0, dim[0]-1):\n\t\tv[i,:,:] = (v[i,:,:].T/np.sum(v[i,:,:],1)).T\n\n\treturn v","def normalize_matrix_on_axis(m, axis=0, copy=True):\n if axis == 0:\n ret = m / np.sqrt(np.sum(m ** 2, axis=axis))\n elif axis == 1:\n ret = normalize_matrix_on_axis(m.T).T\n else:\n raise Exception('Only for 2D array.')\n if copy:\n ret = ret.copy()\n return ret","def _l2_normalize(x, axis=None, eps=1e-12):\n return x * jax.lax.rsqrt((x * x).sum(axis=axis, keepdims=True) + eps)","def complex_normalize(X, axis=-1):\n mags = np.linalg.norm(np.abs(X), axis=axis, keepdims=True)\n return X / mags","def normalize(x):\n MEAN_VALUES = np.array([104, 117, 123])\n means = theano.shared(MEAN_VALUES.astype(\"float32\"))\n return x[:, ::-1, :, :] - means[np.newaxis, :, np.newaxis, np.newaxis]","def log_normalize(a, axis=None):\n if axis is not None and a.shape[axis] == 1:\n # Handle single-state GMMHMM in the degenerate case normalizing a\n # single -inf to zero.\n a[:] = 0\n else:\n with np.errstate(under=\"ignore\"):\n a_lse = logsumexp(a, axis, keepdims=True)\n a -= a_lse","def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)","def _normalize(images):\n images -= images.mean(axis=0, keepdims=True)\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)","def normalize(my_array: np.ndarray) -> np.ndarray:\n\n return np.abs(my_array)/np.max(np.abs(my_array))","def normalised(cls, mat, axis=-1, order=2):\n norm = np.linalg.norm(\n mat, axis=axis, ord=order, keepdims=True)\n norm[norm == 0] = 1\n return mat / norm","def l1_normalize(x: np.ndarray) -> np.ndarray: # pylint: disable=invalid-name\n return x / x.sum()","def l2_normalize(data, eps, axis=None):\n return cpp.nn.l2_normalize(data, eps, axis)","def normalize(a):\n a = np.array(a)\n return a / np.linalg.norm(a)","def normalize_2d_or_1d(a,\n method,\n axis=None,\n rank_scale=10000,\n normalizing_mean=None,\n normalizing_std=None,\n normalizing_min=None,\n normalizing_max=None,\n normalizing_size=None):\n\n if rank(a) == 1:\n n_a = normalize_1d(\n a,\n method,\n rank_scale=rank_scale,\n normalizing_mean=normalizing_mean,\n normalizing_std=normalizing_std,\n normalizing_min=normalizing_min,\n normalizing_max=normalizing_max,\n normalizing_size=normalizing_size)\n if isinstance(a, Series):\n return Series(n_a, index=a.index)\n else:\n return n_a\n\n elif rank(a) == 2:\n if isinstance(a, DataFrame):\n if axis == 0 or axis == 1:\n return a.apply(\n normalize_1d,\n **{\n 'method': method,\n 'rank_scale': rank_scale,\n 'normalizing_mean': normalizing_mean,\n 'normalizing_std': normalizing_std,\n 'normalizing_min': normalizing_min,\n 'normalizing_max': normalizing_max,\n 'normalizing_size': normalizing_size\n },\n axis=axis)\n\n else:\n\n # Get normalizing size\n if normalizing_size is not None:\n size = normalizing_size\n else:\n size = a.values.size\n\n if method == '-0-':\n\n # Get normalizing mean\n if normalizing_mean is not None:\n mean = normalizing_mean\n else:\n mean = a.values.mean()\n\n # Get normalizing STD\n if normalizing_std is not None:\n std = normalizing_std\n else:\n std = a.values.std()\n\n # Normalize\n if std == 0:\n print(\n 'Not \\'0-1\\' normalizing (std = 0), but \\'/ size\\' normalizing ...'\n )\n return a / size\n else:\n return (a - mean) / std\n\n elif method == '0-1':\n\n # Get normalizing min\n if normalizing_min is not None:\n min_ = normalizing_min\n else:\n min_ = a.values.min()\n\n # Get normalizing max\n if normalizing_max is not None:\n max_ = normalizing_max\n else:\n max_ = a.values.max()\n\n # Normalize\n if max_ - min_ == 0:\n print(\n 'Not \\'0-1\\' normalizing (max - min = 0), but \\'/ size\\' normalizing ...'\n )\n return a / size\n else:\n return (a - min_) / (max_ - min_)\n\n elif method == 'rank':\n raise ValueError(\n 'Normalizing combination of \\'rank\\' & axis=\\'all\\' has not been implemented yet.'\n )\n else:\n raise ValueError('Can\\'t normalize >2 dimensional array-like.')","def normalize(\n ds: xr.Dataset,\n *,\n dim: str,\n kind: str = ADDITIVE,\n) -> xr.Dataset:\n\n if \"norm\" in ds:\n norm = invert(ds.norm, kind)\n else:\n norm = invert(ds.data.mean(dim=dim), kind)\n\n return xr.Dataset(dict(data=apply_correction(ds.data, norm, kind)))","def L2_norm(x, axis=-1):\n return keras.backend.l2_normalize(x, axis=axis)","def copnorm_nd(x, axis=-1):\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\n return np.apply_along_axis(copnorm_1d, axis, x)","def copnorm_nd(x, axis=-1):\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\n return np.apply_along_axis(copnorm_1d, axis, x)","def normFloatArray(imgIn):\n imgOut = imgIn.copy()\n if imgIn.max()==imgIn.min():\n imgOut = np.zeros(imgIn.shape)\n elif len(imgIn.shape)==2: \n imgOut = (imgOut - imgOut.min())/(imgOut.max()-imgOut.min())\n elif len(imgIn.shape)==3:\n for c in range(3):\n imgOut[:,:,c] = (imgOut[:,:,c] - imgOut[:,:,c].min())/(imgOut[:,:,c].max()-imgOut[:,:,c].min())\n return imgOut.astype(np.float32)","def _normalize_(x: np.array) -> np.array:\n if x.max() != 0:\n x = x / x.max()\n return np.clip(x, 0, 1)# ensure that no values are >1\n else:\n raise ZeroDivisionError('Image Normalization')","def normalize(self):\n self._data /= self.norm()","def normalize(im: np.ndarray) -> np.ndarray:\n im = im.astype(np.float32)\n return (im - im.min()) / (im.max() - im.min())","def normalize(data: np.ndarray, axis=0, order=2) -> tuple[np.ndarray, np.ndarray]:\n norms = np.linalg.norm(data, ord=order, axis=axis, keepdims=True)\n return (\n data / norms,\n norms,\n )","def normalize(dataset):\n minVals = dataset.min(axis=0)\n maxVals = dataset.max(axis=0)\n factors = maxVals-minVals\n num = dataset.shape[0]\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \n return norm_data","def normalize_vector_array (vector_array ):\r\n norms = np.linalg.norm (vector_array, axis=1 )\r\n norms = np.where (norms == 0, 1, norms ) # these filtered values belong to arrays that already are normalized\r\n\r\n return vector_array / norms.reshape (-1, 1 )","def normalize(X, Y=None):\r\n # # It would be possible to normalize with last rather than mean, such as:\r\n # lasts = np.expand_dims(X[:, -1, :], axis=1)\r\n # assert (lasts[:, :] == X[:, -1, :]).all(), \"{}, {}, {}. {}\".format(lasts[:, :].shape, X[:, -1, :].shape, lasts[:, :], X[:, -1, :])\r\n mean = np.expand_dims(np.average(X, axis=1) + 0.00001, axis=1)\r\n stddev = np.expand_dims(np.std(X, axis=1) + 0.00001, axis=1)\r\n # print (mean.shape, stddev.shape)\r\n # print (X.shape, Y.shape)\r\n X = X - mean\r\n X = X / (2.5 * stddev)\r\n if Y is not None:\r\n #assert Y.shape == X.shape, (Y.shape, X.shape)\r\n Y = Y - mean\r\n Y = Y / (2.5 * stddev)\r\n return X, Y\r\n return X","def normalize(array):\n array_min, array_max = array.min(), array.max()\n return ((array - array_min)/(array_max - array_min))","def normalize(data):\n # normalize data and return\n # https://stackoverflow.com/questions/29661574/normalize-numpy-array-columns-in-python\n return (data - data.min(axis=0)) / data.ptp(axis=0)","def normalize_rank(x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalize_rank(x, axis=-1):\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\n return x","def normalize(array):\n\treturn array/np.max(array)","def normalize(array):\n high = array.max()\n low = array.min()\n rng = high - low\n array[:] = 1.0 - ((high - array) / rng)","def normalize(X):\n # z-score\n mean = np.mean(X, axis=(0, 1, 2, 3))\n std = np.std(X, axis=(0, 1, 2, 3))\n # avoid dividing zero by adding a very small number\n X = (X - mean) / (std + 1e-7)\n\n return X","def normalize(x):\n # TODO: Implement Function\n data_max = np.max(x)\n data_min = np.min(x)\n x = (x - data_min) / (data_max - data_min)\n return x","def normalizerows(x):\n # Compute x_norm as the norm 2 of x. Use np.linalg.norm(..., ord=2, axis= ..., keepdims=True)\n x_norm = np.linalg.norm(x, ord=2, axis=1, keepdims=True)\n\n #Divide x by norm\n x = x / x_norm\n\n return x","def _norm_along_last_axis(x):\n return np.sqrt(np.sum(np.square(x), axis=x.ndim - 1))","def normalize_data(X, range_d = None):\n n,d = X.shape\n\n if range_d is None:\n range_d = np.zeros([2,d])\n range_d[0,:] = np.min(X, axis = 0)\n range_d[1,:] = np.max(X, axis = 0)\n\n X = (X - range_d[0,:]) / (range_d[1,:] - range_d[0,:])\n\n return X","def np_normalize_image_channels(img_array, per_channel_mean=None, per_channel_stddev=None, clamp_to_range=False, inplace=False):\n # type: (np.ndarray, np.ndarray, np.ndarray, bool, bool) -> np.ndarray\n if inplace:\n normalized_img_array = img_array.astype(np.float32)\n else:\n normalized_img_array = copy.deepcopy(img_array).astype(np.float32)\n\n if np.min(normalized_img_array) < 0 or np.max(normalized_img_array) > 255:\n raise ValueError('Image values are not in range [0, 255], got [{}, {}]'.format(np.min(normalized_img_array), np.max(normalized_img_array)))\n\n normalized_img_array = ((normalized_img_array/255.0) - 0.5) * 2.0\n\n # Subtract the per-channel-mean from the batch to \"center\" the data.\n if per_channel_mean is not None:\n _per_channel_mean = np.array(per_channel_mean).astype(np.float32)\n\n # Per channel mean is in range [-1,1]\n if (_per_channel_mean >= -1.0 - 1e-7).all() and (_per_channel_mean <= 1.0 + 1e-7).all():\n normalized_img_array -= _per_channel_mean\n # Per channel mean is in range [0, 255]\n elif (_per_channel_mean >= 0.0).all() and (_per_channel_mean <= 255.0).all():\n normalized_img_array -= np_from_255_to_normalized(_per_channel_mean)\n else:\n raise ValueError('Per channel mean is in unknown range: {}'.format(_per_channel_mean))\n\n # Additionally, you ideally would like to divide by the sttdev of\n # that feature or pixel as well if you want to normalize each feature\n # value to a z-score.\n if per_channel_stddev is not None:\n _per_channel_stddev = np.array(per_channel_stddev).astype(np.float32)\n\n # Per channel stddev is in range [-1, 1]\n if (_per_channel_stddev >= -1.0 - 1e-7).all() and (_per_channel_stddev <= 1.0 + 1e-7).all():\n normalized_img_array /= _per_channel_stddev\n # Per channel stddev is in range [0, 255]\n elif (_per_channel_stddev >= 0.0).all() and (_per_channel_stddev <= 255.0).all():\n normalized_img_array /= np_from_255_to_normalized(_per_channel_stddev)\n else:\n raise ValueError('Per-channel stddev is in unknown range: {}'.format(_per_channel_stddev))\n\n if clamp_to_range:\n min_val = np.min(normalized_img_array)\n max_val = np.max(normalized_img_array)\n\n if min_val < -1.0 or max_val > 1.0:\n print 'WARNING: Values outside of range [-1.0, 1.0] were found after normalization - clipping: [{}, {}]'.format(min_val, max_val)\n normalized_img_array = np.clip(normalized_img_array, -1.0, 1.0, out=normalized_img_array)\n\n # Sanity check for the image values, we shouldn't have any NaN or inf values\n if np.any(np.isnan(normalized_img_array)):\n raise ValueError('NaN values found in image after normalization')\n\n if np.any(np.isinf(normalized_img_array)):\n raise ValueError('Inf values found in image after normalization')\n\n return normalized_img_array","def normalize(arr):\n arr = arr.astype('float')\n # Do not touch the alpha channel\n for i in range(1):\n minval = arr[...,i].min()\n maxval = arr[...,i].max()\n if minval != maxval:\n arr[...,i] -= minval\n arr[...,i] *= (255.0/(maxval-minval))\n return arr","def normalize(array):\n\n # calculate the mean of array\n array_mean = numpy.mean(array)\n if _DEBUG:\n print \"Mean of gr is:\"\n print array_mean\n\n # divide all elements by the mean\n norm_list = []\n for item in array:\n norm_list.append(item/array_mean - 1)\n\n # return the result\n return norm_list","def normalizeRows(x):\n\n ### YOUR CODE HERE\n norm2 = np.linalg.norm(x,2,axis = 1).reshape(x.shape[0],-1)\n x = x/norm2\n ### END YOUR CODE\n\n return x","def variance_normalize(self):\n self.img = self.img / np.sqrt(np.sum(self.img ** 2))","def normalize(batch_img: np.ndarray) -> np.ndarray:\n batch_img = batch_img.astype('float32')\n return batch_img / 127.5 - 1","def standardize(X, axis=0, ddof=0):\n\n # Modified from scikit-learn.preprocessing.scale()!\n\n #X = np.asarray(X)\n X = np.asarray(X, dtype=np.float) # XXX: what about dtype? convert to float64? for higher precision? let client decide?\n Xr = np.rollaxis(X, axis) # view on X to enable broadcasting on the axis we are interested in\n \n mean_ = Xr.mean(axis=0)\n std_ = Xr.std(axis=0, ddof=ddof)\n std_[std_ == 0.0] = 1.0 # avoid NaNs due to div/zero\n\n # center mean on zero\n Xr -= mean_\n\n # Verify that mean_1 is 'close to zero'. If X contains very\n # large values, mean_1 can also be very large, due to a lack of\n # precision of mean_. In this case, a pre-scaling of the\n # concerned feature is efficient, for instance by its mean or\n # maximum.\n mean_1 = Xr.mean(axis=0)\n if not np.allclose(mean_1, 0.0):\n warnings.warn(\"Numerical issues were encountered \"\n \"when centering the data \"\n \"and might not be solved. Dataset may \"\n \"contain too large values. You may need \"\n \"to prescale your features.\")\n Xr -= mean_1\n mean_ += mean_1\n\n # scale to unit variance\n Xr /= std_\n\n # If mean_2 is not 'close to zero', it comes from the fact that\n # std_ is very small so that mean_2 = mean_1/std_ > 0, even if\n # mean_1 was close to zero. The problem is thus essentially due\n # to the lack of precision of mean_. A solution is then to\n # substract the mean again.\n mean_2 = Xr.mean(axis=0)\n if not np.allclose(mean_2, 0.0):\n warnings.warn(\"Numerical issues were encountered \"\n \"when scaling the data \"\n \"and might not be solved. The standard \"\n \"deviation of the data is probably \"\n \"very close to 0.\")\n Xr -= mean_2\n mean_ += mean_2\n\n # Additional check if variances are 'close to one'\n std_1 = Xr.std(axis=0, ddof=ddof)\n if not np.allclose(std_1, 1.0):\n warnings.warn(\"Numerical issues were encountered \"\n \"when scaling the data \"\n \"and might not be solved. Standard deviation \"\n \"not close to one after scaling.\")\n\n return X, mean_, std_","def normalizeRows(x):\n\n ### YOUR CODE HERE\n # using l2 norm to normalize\n x = x / np.sqrt(np.sum(x * x, axis=-1, keepdims=True))\n ### END YOUR CODE\n\n return x","def normalize(w: torch.Tensor):\n\n if w.dim() > 1:\n return _matrix(w)\n\n return _vector(w)","def log_normalize(log_prob, axis):\n log_sum = logsumexp(log_prob, axis=axis)\n \n if not isinstance(log_sum, np.ndarray):\n log_sum = np.array([log_sum])\n if log_prob.shape[0] == log_sum.shape[0]:\n # column normalize \n return (log_prob.transpose() - log_sum).transpose()\n else:\n # row normalize\n return log_prob - log_sum","def normalize(self, arr):\r\n\r\n\t\t#Set the cap for arr at self.value_max and self.value_max\r\n\t\t#this prevents outliers of breaking the previously predicted p_func\r\n\t\tarr_capped = arr * (arr <= self.value_max) + self.value_max * (arr > self.value_max)\t#cap to value_max\r\n\t\tarr_capped = arr_capped * (arr_capped >= self.value_min) + self.value_min * (arr_capped < self.value_min)\t#cap to value_min\r\n\r\n\t\t#Normalize array\r\n\t\tnorm_factor = self.get_norm_factor(arr_capped)\r\n\t\tnormalized = arr * norm_factor\r\n\r\n\t\treturn(normalized)","def BatchNormalize(S):\n mu = np.mean(S, axis=0)\n v = np.mean((S-mu)**2, axis=0)\n S = (S - mu) / np.sqrt(v + epsilon)\n return S","def normalize(arr, stats=False):\n arr = np.array(arr)\n mean = arr.mean()\n std = arr.std()\n normed = (arr - mean) / std\n if not stats:\n return normed\n return normed, mean, std","def normalize_axis(axis, ndim):\n if axis is None:\n return None\n\n if isinstance(axis, Integral):\n axis = int(axis)\n if axis < 0:\n axis += ndim\n\n if axis >= ndim or axis < 0:\n raise ValueError('Invalid axis index %d for ndim=%d' % (axis, ndim))\n\n return axis\n\n if isinstance(axis, Iterable):\n if not all(isinstance(a, Integral) for a in axis):\n raise ValueError(\"axis %s not understood\" % axis)\n\n return tuple(normalize_axis(a, ndim) for a in axis)\n\n raise ValueError(\"axis %s not understood\" % axis)"],"string":"[\n \"def normalize(a, axis=None):\\n a_sum = a.sum(axis)\\n if axis and a.ndim > 1:\\n a_sum[a_sum == 0] = 1\\n shape = list(a.shape)\\n shape[axis] = 1\\n a_sum.shape = shape\\n\\n return a / a_sum\",\n \"def normalize_axis(x, axis, dtype=float):\\n x = x.astype(dtype)\\n ind_list = [slice(None) for i in range(x.ndim)]\\n try:\\n for i in range(x.shape[axis]):\\n ind_list[axis] = i\\n ind = tuple(ind_list)\\n minn = x[ind].min()\\n maxx = x[ind].max()\\n x[ind] = (x[ind]-minn) / (maxx-minn)\\n except IndexError:\\n raise np.AxisError(\\n \\\"axis {} is out of bounds for array of dimension {}\\\".format(\\n axis, x.ndim\\n )\\n )\\n return x\",\n \"def normalize(X, norm=..., *, axis=..., copy=..., return_norm=...):\\n ...\",\n \"def normalize(X, axis=-1, order=2):\\n l2 = np.atleast_1d(np.linalg.norm(X, order, axis))\\n l2[l2 == 0] = 1\\n return X / np.expand_dims(l2, axis)\",\n \"def _normalize(X: np.ndarray) -> np.ndarray:\\n # return X * np.sqrt(1 / np.sum(X ** 2, axis=1))[:, None]\\n return X * np.sqrt(X.shape[1] / np.sum(X ** 2, axis=1))[:, None]\",\n \"def normalised(a: np.ndarray, order: int = None, axis: int = -1) -> np.ndarray:\\n norm = np.atleast_1d(np.linalg.norm(a, order, axis))\\n return a / np.expand_dims(norm, axis)\",\n \"def normalize_array(array):\\n\\n return array / np.sum(array, axis=1)[:, np.newaxis]\",\n \"def normalize(x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalize(x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalize(x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalized(a, axis=-1, order=2):\\n l2 = np.atleast_1d(np.linalg.norm(a, order, axis))\\n l2[l2==0] = 1\\n return a / np.expand_dims(l2, axis)\",\n \"def normalize(inp):\\n\\n out = inp / np.linalg.norm(inp, axis=1, keepdims=True)\\n\\n return out\",\n \"def normalize(self, x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalise(x, dim=1):\\n norm = torch.sqrt( torch.pow(x,2.).sum(dim) )\\n if dim>0:\\n x /= norm.unsqueeze(dim)\\n return x\",\n \"def image_normalize(im, axis=(0, 1), c=1e-8):\\n return (im - im.mean(axis)) / (im.std(axis) + c)\",\n \"def __normalize_after_fft(arr):\\n\\n n1, n2 = arr.shape[0], arr.shape[1]\\n for i in range(n1):\\n for j in range(n2):\\n arr[i, j] *= n1 * n2\\n\\n return arr\",\n \"def normalize(X):\\n\\tX = X - np.mean(X,axis=1)[:,np.newaxis]\\n\\tX = X/np.std(X,axis=0)[np.newaxis,:];\\n\\tX = X - np.mean(X,axis=0)[np.newaxis,:]\\n\\treturn X\",\n \"def normalize(arr, eps):\\n\\n norm = cuda.reduce('T x', 'T out',\\n 'x * x', 'a + b', 'out = sqrt(a)', 0,\\n 'norm_sn')(arr)\\n cuda.elementwise('T norm, T eps',\\n 'T x',\\n 'x /= (norm + eps)',\\n 'div_sn')(norm, eps, arr)\\n return norm\",\n \"def l2_normalize(data, axis=-1, eps=1e-6):\\n ret = data / (np.linalg.norm(data, axis=axis, keepdims=True) + eps)\\n return ret\",\n \"def normalize(array, norm=\\\"l2\\\"):\\n scaler = Normalizer(copy=True, norm=norm)\\n return scaler.fit_transform(array)\",\n \"def normalise(self):\\n return self / self.mean(axis=1).reshape(self.shape[0], 1)\",\n \"def vector_normalize(vec, axis=None):\\n mag = vector_magnitude(vec, axis=axis)\\n mag = mag if mag > 0 else 1\\n if axis is None:\\n return vec / mag\\n else:\\n axis_ix = [None] * len(vec.shape)\\n axis_ix[axis] = slice(None, None, None)\\n return vec / numpy.array([mag])[axis_ix]\",\n \"def _normalize(\\n ds: xr.Dataset,\\n *,\\n dim: Sequence[str],\\n kind: str = ADDITIVE,\\n) -> xr.Dataset:\\n if \\\"norm\\\" in ds:\\n norm = ds.norm\\n else:\\n norm = ds.data.mean(dim=dim)\\n norm.attrs[\\\"_group_apply_reshape\\\"] = True\\n\\n return xr.Dataset(\\n dict(data=apply_correction(ds.data, invert(norm, kind), kind), norm=norm)\\n )\",\n \"def normalize(arr):\\n m = np.min(arr)\\n arr = arr - m\\n M = np.max(arr)\\n arr = arr / M\\n return arr\",\n \"def naive_act_norm_initialize(x, axis):\\n x = np.asarray(x)\\n axis = list(sorted(set([a + len(x.shape) if a < 0 else a for a in axis])))\\n min_axis = np.min(axis)\\n reduce_axis = tuple(a for a in range(len(x.shape)) if a not in axis)\\n var_shape = [x.shape[a] for a in axis]\\n var_shape_aligned = [x.shape[a] if a in axis else 1\\n for a in range(min_axis, len(x.shape))]\\n mean = np.reshape(np.mean(x, axis=reduce_axis), var_shape)\\n bias = -mean\\n scale = 1. / np.reshape(\\n np.sqrt(np.mean((x - np.reshape(mean, var_shape_aligned)) ** 2,\\n axis=reduce_axis)),\\n var_shape\\n )\\n return scale, bias, var_shape_aligned\",\n \"def normalize(tensor: np.ndarray):\\n if len(tensor.shape) < 4:\\n tensor = np.expand_dims(tensor, axis=2)\\n mean = np.array([tensor[..., chn, :].mean() for chn in range(tensor.shape[2])])\\n std = np.array([tensor[..., chn, :].std() for chn in range(tensor.shape[2])])\\n return (tensor - mean[:, np.newaxis]) / std[:, np.newaxis]\",\n \"def normalize(x):\\n\\n x_norm = np.linalg.norm(x, axis=1, keepdims=True)\\n print(x_norm)\\n x = x / x_norm\\n ### END\\n\\n return x\",\n \"def normalize(array, inplace=False):\\n if inplace:\\n array -= ds_mean\\n array /= ds_std\\n else:\\n array = (array - ds_mean) / ds_std\\n return array\",\n \"def _normalize(self, x, axis, eps=1e-5):\\n return x / (\\n tf.sqrt(tf.reduce_sum(tf.square(x), axis=axis, keep_dims=True)) + 1e-5)\",\n \"def _scale(x, axis=None):\\n x = _remove_baseline(x, axis=axis)\\n x /= np.std(x, ddof=1, axis=axis, keepdims=True)\\n return x\",\n \"def normalize(A, normRange, normAxis):\\n\\n shape = A.shape\\n # make a slice to take the mean in the right dimension\\n # slice(None) effectively means ':', or all the elements\\n normSlice = [slice(normRange[0], normRange[1]) if a is normAxis else slice(None) for a in range(len(shape))]\\n norm = np.mean(A[normSlice], axis=normAxis)\\n\\n # make a slice to pad the numbers to make the broadcasting work\\n # again, slice(None) means ':' and None means an empty dimension (note difference!)\\n\\n try:\\n return A/norm\\n except:\\n subSlice=[slice(None) if axis == norm.shape[0] else None for axis in shape]\\n return A / norm[subSlice]\\n finally:\\n pass\",\n \"def normalize(arr: np.ndarray) -> np.ndarray:\\n if max(arr) - min(arr) == 0:\\n logger.warning(\\n \\\"Normalize averted a div/0, the input data was:\\\\n {0}\\\".format(arr)\\n )\\n return np.ones(len(arr))\\n return (arr - min(arr)) / (max(arr) - min(arr))\",\n \"def normalize(A: np.array) -> np.array:\\n for i in range(A.shape[1]):\\n A[:, i] = (A[:, i] - np.min(A[:, i])) / (np.max(A[:, i] - np.min(A[:, i])))\\n return A\",\n \"def normalize_data(img):\\n nor = np.linalg.norm(img, axis = 1)\\n nor = np.reshape(nor, (len(img), 1))\\n img = np.divide(img, nor)\\n return img\",\n \"def demean_normalize(one_d_array):\\n\\n temp_arr = one_d_array - np.nanmean(one_d_array)\\n\\n return temp_arr/np.nanstd(temp_arr)\",\n \"def normalize(data):\\n data = numpy.asmatrix(data)\\n std_devs = numpy.std(data, axis=1)\\n std_devs[std_devs == 0] = 1 # prevent div by 0\\n return (data - numpy.mean(data, axis=1)) / std_devs\",\n \"def normalize_data(data=None):\\n # Data pre-processing\\n n = data.shape[0]\\n for i in range(n):\\n xx = data[i,:,:]\\n xx -= np.mean(xx) # Centering in 0\\n xx /= np.linalg.norm(xx) # Normalizing to 1\\n data[i] = xx # Affect value\\n return data\",\n \"def _normalize(x):\\n tol = 1e-10\\n dims = x.shape\\n\\n x = x.flatten()\\n inverse = (np.sum(x**2) + tol) ** -.5\\n x = x * inverse\\n x = np.reshape(x, dims)\\n\\n return x\",\n \"def normalise(x):\\n x = np.copy(x)\\n n_cols = x.shape[1]\\n for col_index in range(n_cols):\\n col = x[:, col_index]\\n factor = np.max(col)\\n x[:, col_index] = col / factor\\n\\n return x\",\n \"def normalize_array(arr, method=\\\"min_max\\\"):\\r\\n \\r\\n ret = torch.tensor(arr)\\r\\n if method == \\\"min_max\\\":\\r\\n ret -= torch.min(ret)\\r\\n ret /= torch.max(ret)\\r\\n elif method == \\\"mean_std\\\":\\r\\n ret -= torch.mean(ret)\\r\\n ret /= torch.std(ret)\\r\\n else:\\r\\n raise Exception(\\\"Invalid normalization method\\\")\\r\\n\\r\\n return 1 + ret\",\n \"def _normalize(weights, axis, log=True):\\n if log:\\n normalizer = tf.reduce_logsumexp(weights, axis=axis, keepdims=True)\\n return weights - normalizer\\n normalizer = tf.reduce_sum(weights, axis=axis)\\n return weights / normalizer\",\n \"def normalize_data(x):\\n mvec = x.mean(0)\\n stdvec = x.std(axis=0)\\n \\n return (x - mvec)/stdvec\",\n \"def normalize_data(x):\\n mvec = x.mean(0)\\n stdvec = x.std(axis=0)\\n \\n return (x - mvec)/stdvec\",\n \"def standardize(x, axis=-1):\\n stds_avg = np.std(x, axis=axis, keepdims=True)\\n x -= np.mean(x, axis=axis, keepdims=True)\\n x /= (stds_avg + 1e-8)\\n return x\",\n \"def normalize(data):\\n row = np.size(data, 0) # number of data points\\n col = np.size(data, 1) # dimensionality of data points\\n for j in range(col):\\n # find the average for each column\\n col_sum = 0\\n for i in range(row):\\n col_sum = col_sum + data[i][j]\\n col_sum = col_sum / row\\n # subtract the average from each value in the column\\n for i in range(row):\\n data[i][j] = data[i][j] - col_sum\\n return data\",\n \"def normalize(data):\\n row = np.size(data, 0) # number of data points\\n col = np.size(data, 1) # dimensionality of data points\\n for j in range(col):\\n # find the average for each column\\n col_sum = 0\\n for i in range(row):\\n col_sum = col_sum + data[i][j]\\n col_sum = col_sum / row\\n # subtract the average from each value in the column\\n for i in range(row):\\n data[i][j] = data[i][j] - col_sum\\n return data\",\n \"def normalize_matrix(matrix, axis=1):\\n if len(matrix.shape) == 1:\\n # turn vector into matrix with one row\\n matrix = matrix[np.newaxis, :]\\n divisor = np.linalg.norm(matrix, axis=axis)[:, np.newaxis]\\n # only normalize where divisor is not zero\\n result = np.divide(matrix, divisor, out=np.zeros(matrix.shape), where=divisor != 0)\\n return result\",\n \"def _normalize_matrix_on_axis(m, axis=0):\\n if m.ndim > 2:\\n raise ValueError(\\n \\\"This function only accepts 2D arrays. \\\"\\n f\\\"An array of shape {m.shape:r} was passed.\\\"\\n )\\n\\n if axis == 0:\\n # array transposition preserves the contiguity flag of that array\\n ret = (m.T / np.sqrt(np.sum(m**2, axis=0))[:, np.newaxis]).T\\n elif axis == 1:\\n ret = _normalize_matrix_on_axis(m.T).T\\n else:\\n raise ValueError(f\\\"axis(={int(axis)}) out of bounds\\\")\\n return ret\",\n \"def _normalize(array):\\n\\treturn (array - np.min(array))/(np.max(array)-np.min(array))\",\n \"def normalize(v):\\n\\tdim = v.shape \\n\\tfor i in range(0, dim[0]-1):\\n\\t\\tv[i,:,:] = (v[i,:,:].T/np.sum(v[i,:,:],1)).T\\n\\n\\treturn v\",\n \"def normalize_matrix_on_axis(m, axis=0, copy=True):\\n if axis == 0:\\n ret = m / np.sqrt(np.sum(m ** 2, axis=axis))\\n elif axis == 1:\\n ret = normalize_matrix_on_axis(m.T).T\\n else:\\n raise Exception('Only for 2D array.')\\n if copy:\\n ret = ret.copy()\\n return ret\",\n \"def _l2_normalize(x, axis=None, eps=1e-12):\\n return x * jax.lax.rsqrt((x * x).sum(axis=axis, keepdims=True) + eps)\",\n \"def complex_normalize(X, axis=-1):\\n mags = np.linalg.norm(np.abs(X), axis=axis, keepdims=True)\\n return X / mags\",\n \"def normalize(x):\\n MEAN_VALUES = np.array([104, 117, 123])\\n means = theano.shared(MEAN_VALUES.astype(\\\"float32\\\"))\\n return x[:, ::-1, :, :] - means[np.newaxis, :, np.newaxis, np.newaxis]\",\n \"def log_normalize(a, axis=None):\\n if axis is not None and a.shape[axis] == 1:\\n # Handle single-state GMMHMM in the degenerate case normalizing a\\n # single -inf to zero.\\n a[:] = 0\\n else:\\n with np.errstate(under=\\\"ignore\\\"):\\n a_lse = logsumexp(a, axis, keepdims=True)\\n a -= a_lse\",\n \"def _normalize(images):\\n images -= images.mean(axis=0, keepdims=True)\\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)\",\n \"def _normalize(images):\\n images -= images.mean(axis=0, keepdims=True)\\n images /= np.maximum(images.std(axis=0, keepdims=True), 3e-1)\",\n \"def normalize(my_array: np.ndarray) -> np.ndarray:\\n\\n return np.abs(my_array)/np.max(np.abs(my_array))\",\n \"def normalised(cls, mat, axis=-1, order=2):\\n norm = np.linalg.norm(\\n mat, axis=axis, ord=order, keepdims=True)\\n norm[norm == 0] = 1\\n return mat / norm\",\n \"def l1_normalize(x: np.ndarray) -> np.ndarray: # pylint: disable=invalid-name\\n return x / x.sum()\",\n \"def l2_normalize(data, eps, axis=None):\\n return cpp.nn.l2_normalize(data, eps, axis)\",\n \"def normalize(a):\\n a = np.array(a)\\n return a / np.linalg.norm(a)\",\n \"def normalize_2d_or_1d(a,\\n method,\\n axis=None,\\n rank_scale=10000,\\n normalizing_mean=None,\\n normalizing_std=None,\\n normalizing_min=None,\\n normalizing_max=None,\\n normalizing_size=None):\\n\\n if rank(a) == 1:\\n n_a = normalize_1d(\\n a,\\n method,\\n rank_scale=rank_scale,\\n normalizing_mean=normalizing_mean,\\n normalizing_std=normalizing_std,\\n normalizing_min=normalizing_min,\\n normalizing_max=normalizing_max,\\n normalizing_size=normalizing_size)\\n if isinstance(a, Series):\\n return Series(n_a, index=a.index)\\n else:\\n return n_a\\n\\n elif rank(a) == 2:\\n if isinstance(a, DataFrame):\\n if axis == 0 or axis == 1:\\n return a.apply(\\n normalize_1d,\\n **{\\n 'method': method,\\n 'rank_scale': rank_scale,\\n 'normalizing_mean': normalizing_mean,\\n 'normalizing_std': normalizing_std,\\n 'normalizing_min': normalizing_min,\\n 'normalizing_max': normalizing_max,\\n 'normalizing_size': normalizing_size\\n },\\n axis=axis)\\n\\n else:\\n\\n # Get normalizing size\\n if normalizing_size is not None:\\n size = normalizing_size\\n else:\\n size = a.values.size\\n\\n if method == '-0-':\\n\\n # Get normalizing mean\\n if normalizing_mean is not None:\\n mean = normalizing_mean\\n else:\\n mean = a.values.mean()\\n\\n # Get normalizing STD\\n if normalizing_std is not None:\\n std = normalizing_std\\n else:\\n std = a.values.std()\\n\\n # Normalize\\n if std == 0:\\n print(\\n 'Not \\\\'0-1\\\\' normalizing (std = 0), but \\\\'/ size\\\\' normalizing ...'\\n )\\n return a / size\\n else:\\n return (a - mean) / std\\n\\n elif method == '0-1':\\n\\n # Get normalizing min\\n if normalizing_min is not None:\\n min_ = normalizing_min\\n else:\\n min_ = a.values.min()\\n\\n # Get normalizing max\\n if normalizing_max is not None:\\n max_ = normalizing_max\\n else:\\n max_ = a.values.max()\\n\\n # Normalize\\n if max_ - min_ == 0:\\n print(\\n 'Not \\\\'0-1\\\\' normalizing (max - min = 0), but \\\\'/ size\\\\' normalizing ...'\\n )\\n return a / size\\n else:\\n return (a - min_) / (max_ - min_)\\n\\n elif method == 'rank':\\n raise ValueError(\\n 'Normalizing combination of \\\\'rank\\\\' & axis=\\\\'all\\\\' has not been implemented yet.'\\n )\\n else:\\n raise ValueError('Can\\\\'t normalize >2 dimensional array-like.')\",\n \"def normalize(\\n ds: xr.Dataset,\\n *,\\n dim: str,\\n kind: str = ADDITIVE,\\n) -> xr.Dataset:\\n\\n if \\\"norm\\\" in ds:\\n norm = invert(ds.norm, kind)\\n else:\\n norm = invert(ds.data.mean(dim=dim), kind)\\n\\n return xr.Dataset(dict(data=apply_correction(ds.data, norm, kind)))\",\n \"def L2_norm(x, axis=-1):\\n return keras.backend.l2_normalize(x, axis=axis)\",\n \"def copnorm_nd(x, axis=-1):\\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\\n return np.apply_along_axis(copnorm_1d, axis, x)\",\n \"def copnorm_nd(x, axis=-1):\\n assert isinstance(x, np.ndarray) and (x.ndim >= 1)\\n return np.apply_along_axis(copnorm_1d, axis, x)\",\n \"def normFloatArray(imgIn):\\n imgOut = imgIn.copy()\\n if imgIn.max()==imgIn.min():\\n imgOut = np.zeros(imgIn.shape)\\n elif len(imgIn.shape)==2: \\n imgOut = (imgOut - imgOut.min())/(imgOut.max()-imgOut.min())\\n elif len(imgIn.shape)==3:\\n for c in range(3):\\n imgOut[:,:,c] = (imgOut[:,:,c] - imgOut[:,:,c].min())/(imgOut[:,:,c].max()-imgOut[:,:,c].min())\\n return imgOut.astype(np.float32)\",\n \"def _normalize_(x: np.array) -> np.array:\\n if x.max() != 0:\\n x = x / x.max()\\n return np.clip(x, 0, 1)# ensure that no values are >1\\n else:\\n raise ZeroDivisionError('Image Normalization')\",\n \"def normalize(self):\\n self._data /= self.norm()\",\n \"def normalize(im: np.ndarray) -> np.ndarray:\\n im = im.astype(np.float32)\\n return (im - im.min()) / (im.max() - im.min())\",\n \"def normalize(data: np.ndarray, axis=0, order=2) -> tuple[np.ndarray, np.ndarray]:\\n norms = np.linalg.norm(data, ord=order, axis=axis, keepdims=True)\\n return (\\n data / norms,\\n norms,\\n )\",\n \"def normalize(dataset):\\n minVals = dataset.min(axis=0)\\n maxVals = dataset.max(axis=0)\\n factors = maxVals-minVals\\n num = dataset.shape[0]\\n norm_data = (dataset - np.tile(minVals,(num,1)))/np.tile(factors,(num,1)) \\n return norm_data\",\n \"def normalize_vector_array (vector_array ):\\r\\n norms = np.linalg.norm (vector_array, axis=1 )\\r\\n norms = np.where (norms == 0, 1, norms ) # these filtered values belong to arrays that already are normalized\\r\\n\\r\\n return vector_array / norms.reshape (-1, 1 )\",\n \"def normalize(X, Y=None):\\r\\n # # It would be possible to normalize with last rather than mean, such as:\\r\\n # lasts = np.expand_dims(X[:, -1, :], axis=1)\\r\\n # assert (lasts[:, :] == X[:, -1, :]).all(), \\\"{}, {}, {}. {}\\\".format(lasts[:, :].shape, X[:, -1, :].shape, lasts[:, :], X[:, -1, :])\\r\\n mean = np.expand_dims(np.average(X, axis=1) + 0.00001, axis=1)\\r\\n stddev = np.expand_dims(np.std(X, axis=1) + 0.00001, axis=1)\\r\\n # print (mean.shape, stddev.shape)\\r\\n # print (X.shape, Y.shape)\\r\\n X = X - mean\\r\\n X = X / (2.5 * stddev)\\r\\n if Y is not None:\\r\\n #assert Y.shape == X.shape, (Y.shape, X.shape)\\r\\n Y = Y - mean\\r\\n Y = Y / (2.5 * stddev)\\r\\n return X, Y\\r\\n return X\",\n \"def normalize(array):\\n array_min, array_max = array.min(), array.max()\\n return ((array - array_min)/(array_max - array_min))\",\n \"def normalize(data):\\n # normalize data and return\\n # https://stackoverflow.com/questions/29661574/normalize-numpy-array-columns-in-python\\n return (data - data.min(axis=0)) / data.ptp(axis=0)\",\n \"def normalize_rank(x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalize_rank(x, axis=-1):\\n x = 1. * x / (torch.norm(x, 2, axis, keepdim=True).expand_as(x) + 1e-12)\\n return x\",\n \"def normalize(array):\\n\\treturn array/np.max(array)\",\n \"def normalize(array):\\n high = array.max()\\n low = array.min()\\n rng = high - low\\n array[:] = 1.0 - ((high - array) / rng)\",\n \"def normalize(X):\\n # z-score\\n mean = np.mean(X, axis=(0, 1, 2, 3))\\n std = np.std(X, axis=(0, 1, 2, 3))\\n # avoid dividing zero by adding a very small number\\n X = (X - mean) / (std + 1e-7)\\n\\n return X\",\n \"def normalize(x):\\n # TODO: Implement Function\\n data_max = np.max(x)\\n data_min = np.min(x)\\n x = (x - data_min) / (data_max - data_min)\\n return x\",\n \"def normalizerows(x):\\n # Compute x_norm as the norm 2 of x. Use np.linalg.norm(..., ord=2, axis= ..., keepdims=True)\\n x_norm = np.linalg.norm(x, ord=2, axis=1, keepdims=True)\\n\\n #Divide x by norm\\n x = x / x_norm\\n\\n return x\",\n \"def _norm_along_last_axis(x):\\n return np.sqrt(np.sum(np.square(x), axis=x.ndim - 1))\",\n \"def normalize_data(X, range_d = None):\\n n,d = X.shape\\n\\n if range_d is None:\\n range_d = np.zeros([2,d])\\n range_d[0,:] = np.min(X, axis = 0)\\n range_d[1,:] = np.max(X, axis = 0)\\n\\n X = (X - range_d[0,:]) / (range_d[1,:] - range_d[0,:])\\n\\n return X\",\n \"def np_normalize_image_channels(img_array, per_channel_mean=None, per_channel_stddev=None, clamp_to_range=False, inplace=False):\\n # type: (np.ndarray, np.ndarray, np.ndarray, bool, bool) -> np.ndarray\\n if inplace:\\n normalized_img_array = img_array.astype(np.float32)\\n else:\\n normalized_img_array = copy.deepcopy(img_array).astype(np.float32)\\n\\n if np.min(normalized_img_array) < 0 or np.max(normalized_img_array) > 255:\\n raise ValueError('Image values are not in range [0, 255], got [{}, {}]'.format(np.min(normalized_img_array), np.max(normalized_img_array)))\\n\\n normalized_img_array = ((normalized_img_array/255.0) - 0.5) * 2.0\\n\\n # Subtract the per-channel-mean from the batch to \\\"center\\\" the data.\\n if per_channel_mean is not None:\\n _per_channel_mean = np.array(per_channel_mean).astype(np.float32)\\n\\n # Per channel mean is in range [-1,1]\\n if (_per_channel_mean >= -1.0 - 1e-7).all() and (_per_channel_mean <= 1.0 + 1e-7).all():\\n normalized_img_array -= _per_channel_mean\\n # Per channel mean is in range [0, 255]\\n elif (_per_channel_mean >= 0.0).all() and (_per_channel_mean <= 255.0).all():\\n normalized_img_array -= np_from_255_to_normalized(_per_channel_mean)\\n else:\\n raise ValueError('Per channel mean is in unknown range: {}'.format(_per_channel_mean))\\n\\n # Additionally, you ideally would like to divide by the sttdev of\\n # that feature or pixel as well if you want to normalize each feature\\n # value to a z-score.\\n if per_channel_stddev is not None:\\n _per_channel_stddev = np.array(per_channel_stddev).astype(np.float32)\\n\\n # Per channel stddev is in range [-1, 1]\\n if (_per_channel_stddev >= -1.0 - 1e-7).all() and (_per_channel_stddev <= 1.0 + 1e-7).all():\\n normalized_img_array /= _per_channel_stddev\\n # Per channel stddev is in range [0, 255]\\n elif (_per_channel_stddev >= 0.0).all() and (_per_channel_stddev <= 255.0).all():\\n normalized_img_array /= np_from_255_to_normalized(_per_channel_stddev)\\n else:\\n raise ValueError('Per-channel stddev is in unknown range: {}'.format(_per_channel_stddev))\\n\\n if clamp_to_range:\\n min_val = np.min(normalized_img_array)\\n max_val = np.max(normalized_img_array)\\n\\n if min_val < -1.0 or max_val > 1.0:\\n print 'WARNING: Values outside of range [-1.0, 1.0] were found after normalization - clipping: [{}, {}]'.format(min_val, max_val)\\n normalized_img_array = np.clip(normalized_img_array, -1.0, 1.0, out=normalized_img_array)\\n\\n # Sanity check for the image values, we shouldn't have any NaN or inf values\\n if np.any(np.isnan(normalized_img_array)):\\n raise ValueError('NaN values found in image after normalization')\\n\\n if np.any(np.isinf(normalized_img_array)):\\n raise ValueError('Inf values found in image after normalization')\\n\\n return normalized_img_array\",\n \"def normalize(arr):\\n arr = arr.astype('float')\\n # Do not touch the alpha channel\\n for i in range(1):\\n minval = arr[...,i].min()\\n maxval = arr[...,i].max()\\n if minval != maxval:\\n arr[...,i] -= minval\\n arr[...,i] *= (255.0/(maxval-minval))\\n return arr\",\n \"def normalize(array):\\n\\n # calculate the mean of array\\n array_mean = numpy.mean(array)\\n if _DEBUG:\\n print \\\"Mean of gr is:\\\"\\n print array_mean\\n\\n # divide all elements by the mean\\n norm_list = []\\n for item in array:\\n norm_list.append(item/array_mean - 1)\\n\\n # return the result\\n return norm_list\",\n \"def normalizeRows(x):\\n\\n ### YOUR CODE HERE\\n norm2 = np.linalg.norm(x,2,axis = 1).reshape(x.shape[0],-1)\\n x = x/norm2\\n ### END YOUR CODE\\n\\n return x\",\n \"def variance_normalize(self):\\n self.img = self.img / np.sqrt(np.sum(self.img ** 2))\",\n \"def normalize(batch_img: np.ndarray) -> np.ndarray:\\n batch_img = batch_img.astype('float32')\\n return batch_img / 127.5 - 1\",\n \"def standardize(X, axis=0, ddof=0):\\n\\n # Modified from scikit-learn.preprocessing.scale()!\\n\\n #X = np.asarray(X)\\n X = np.asarray(X, dtype=np.float) # XXX: what about dtype? convert to float64? for higher precision? let client decide?\\n Xr = np.rollaxis(X, axis) # view on X to enable broadcasting on the axis we are interested in\\n \\n mean_ = Xr.mean(axis=0)\\n std_ = Xr.std(axis=0, ddof=ddof)\\n std_[std_ == 0.0] = 1.0 # avoid NaNs due to div/zero\\n\\n # center mean on zero\\n Xr -= mean_\\n\\n # Verify that mean_1 is 'close to zero'. If X contains very\\n # large values, mean_1 can also be very large, due to a lack of\\n # precision of mean_. In this case, a pre-scaling of the\\n # concerned feature is efficient, for instance by its mean or\\n # maximum.\\n mean_1 = Xr.mean(axis=0)\\n if not np.allclose(mean_1, 0.0):\\n warnings.warn(\\\"Numerical issues were encountered \\\"\\n \\\"when centering the data \\\"\\n \\\"and might not be solved. Dataset may \\\"\\n \\\"contain too large values. You may need \\\"\\n \\\"to prescale your features.\\\")\\n Xr -= mean_1\\n mean_ += mean_1\\n\\n # scale to unit variance\\n Xr /= std_\\n\\n # If mean_2 is not 'close to zero', it comes from the fact that\\n # std_ is very small so that mean_2 = mean_1/std_ > 0, even if\\n # mean_1 was close to zero. The problem is thus essentially due\\n # to the lack of precision of mean_. A solution is then to\\n # substract the mean again.\\n mean_2 = Xr.mean(axis=0)\\n if not np.allclose(mean_2, 0.0):\\n warnings.warn(\\\"Numerical issues were encountered \\\"\\n \\\"when scaling the data \\\"\\n \\\"and might not be solved. The standard \\\"\\n \\\"deviation of the data is probably \\\"\\n \\\"very close to 0.\\\")\\n Xr -= mean_2\\n mean_ += mean_2\\n\\n # Additional check if variances are 'close to one'\\n std_1 = Xr.std(axis=0, ddof=ddof)\\n if not np.allclose(std_1, 1.0):\\n warnings.warn(\\\"Numerical issues were encountered \\\"\\n \\\"when scaling the data \\\"\\n \\\"and might not be solved. Standard deviation \\\"\\n \\\"not close to one after scaling.\\\")\\n\\n return X, mean_, std_\",\n \"def normalizeRows(x):\\n\\n ### YOUR CODE HERE\\n # using l2 norm to normalize\\n x = x / np.sqrt(np.sum(x * x, axis=-1, keepdims=True))\\n ### END YOUR CODE\\n\\n return x\",\n \"def normalize(w: torch.Tensor):\\n\\n if w.dim() > 1:\\n return _matrix(w)\\n\\n return _vector(w)\",\n \"def log_normalize(log_prob, axis):\\n log_sum = logsumexp(log_prob, axis=axis)\\n \\n if not isinstance(log_sum, np.ndarray):\\n log_sum = np.array([log_sum])\\n if log_prob.shape[0] == log_sum.shape[0]:\\n # column normalize \\n return (log_prob.transpose() - log_sum).transpose()\\n else:\\n # row normalize\\n return log_prob - log_sum\",\n \"def normalize(self, arr):\\r\\n\\r\\n\\t\\t#Set the cap for arr at self.value_max and self.value_max\\r\\n\\t\\t#this prevents outliers of breaking the previously predicted p_func\\r\\n\\t\\tarr_capped = arr * (arr <= self.value_max) + self.value_max * (arr > self.value_max)\\t#cap to value_max\\r\\n\\t\\tarr_capped = arr_capped * (arr_capped >= self.value_min) + self.value_min * (arr_capped < self.value_min)\\t#cap to value_min\\r\\n\\r\\n\\t\\t#Normalize array\\r\\n\\t\\tnorm_factor = self.get_norm_factor(arr_capped)\\r\\n\\t\\tnormalized = arr * norm_factor\\r\\n\\r\\n\\t\\treturn(normalized)\",\n \"def BatchNormalize(S):\\n mu = np.mean(S, axis=0)\\n v = np.mean((S-mu)**2, axis=0)\\n S = (S - mu) / np.sqrt(v + epsilon)\\n return S\",\n \"def normalize(arr, stats=False):\\n arr = np.array(arr)\\n mean = arr.mean()\\n std = arr.std()\\n normed = (arr - mean) / std\\n if not stats:\\n return normed\\n return normed, mean, std\",\n \"def normalize_axis(axis, ndim):\\n if axis is None:\\n return None\\n\\n if isinstance(axis, Integral):\\n axis = int(axis)\\n if axis < 0:\\n axis += ndim\\n\\n if axis >= ndim or axis < 0:\\n raise ValueError('Invalid axis index %d for ndim=%d' % (axis, ndim))\\n\\n return axis\\n\\n if isinstance(axis, Iterable):\\n if not all(isinstance(a, Integral) for a in axis):\\n raise ValueError(\\\"axis %s not understood\\\" % axis)\\n\\n return tuple(normalize_axis(a, ndim) for a in axis)\\n\\n raise ValueError(\\\"axis %s not understood\\\" % axis)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.79087126","0.77035505","0.7302382","0.7287287","0.72832733","0.71538836","0.70283896","0.69810927","0.69810927","0.69810927","0.6960576","0.69318247","0.68613905","0.68207276","0.6742309","0.67182606","0.6710599","0.669388","0.665268","0.6642963","0.66315585","0.66134095","0.6604372","0.66020936","0.6598878","0.65720874","0.6569174","0.656865","0.6560761","0.6529997","0.652892","0.65239424","0.6513375","0.6465449","0.6451112","0.6449124","0.64327306","0.64072645","0.63879293","0.6377251","0.636544","0.636476","0.636476","0.63597184","0.6349237","0.6349237","0.6342595","0.63303626","0.63217103","0.6317641","0.6309279","0.6274506","0.62740934","0.627082","0.6256646","0.625656","0.625656","0.62477696","0.6228595","0.6219961","0.62197614","0.6201411","0.62001574","0.61953145","0.61939406","0.61876374","0.61876374","0.61814755","0.6175068","0.6169846","0.61517787","0.6146204","0.61414796","0.6124434","0.61184126","0.6117911","0.6089947","0.608412","0.608412","0.6081994","0.6077599","0.60716945","0.6068972","0.6064593","0.6062132","0.6055589","0.6045716","0.60455453","0.6043081","0.6022775","0.6022267","0.60211986","0.6007773","0.6004294","0.5982393","0.5966404","0.595726","0.5956153","0.5935539","0.5934698"],"string":"[\n \"0.79087126\",\n \"0.77035505\",\n \"0.7302382\",\n \"0.7287287\",\n \"0.72832733\",\n \"0.71538836\",\n \"0.70283896\",\n \"0.69810927\",\n \"0.69810927\",\n \"0.69810927\",\n \"0.6960576\",\n \"0.69318247\",\n \"0.68613905\",\n \"0.68207276\",\n \"0.6742309\",\n \"0.67182606\",\n \"0.6710599\",\n \"0.669388\",\n \"0.665268\",\n \"0.6642963\",\n \"0.66315585\",\n \"0.66134095\",\n \"0.6604372\",\n \"0.66020936\",\n \"0.6598878\",\n \"0.65720874\",\n \"0.6569174\",\n \"0.656865\",\n \"0.6560761\",\n \"0.6529997\",\n \"0.652892\",\n \"0.65239424\",\n \"0.6513375\",\n \"0.6465449\",\n \"0.6451112\",\n \"0.6449124\",\n \"0.64327306\",\n \"0.64072645\",\n \"0.63879293\",\n \"0.6377251\",\n \"0.636544\",\n \"0.636476\",\n \"0.636476\",\n \"0.63597184\",\n \"0.6349237\",\n \"0.6349237\",\n \"0.6342595\",\n \"0.63303626\",\n \"0.63217103\",\n \"0.6317641\",\n \"0.6309279\",\n \"0.6274506\",\n \"0.62740934\",\n \"0.627082\",\n \"0.6256646\",\n \"0.625656\",\n \"0.625656\",\n \"0.62477696\",\n \"0.6228595\",\n \"0.6219961\",\n \"0.62197614\",\n \"0.6201411\",\n \"0.62001574\",\n \"0.61953145\",\n \"0.61939406\",\n \"0.61876374\",\n \"0.61876374\",\n \"0.61814755\",\n \"0.6175068\",\n \"0.6169846\",\n \"0.61517787\",\n \"0.6146204\",\n \"0.61414796\",\n \"0.6124434\",\n \"0.61184126\",\n \"0.6117911\",\n \"0.6089947\",\n \"0.608412\",\n \"0.608412\",\n \"0.6081994\",\n \"0.6077599\",\n \"0.60716945\",\n \"0.6068972\",\n \"0.6064593\",\n \"0.6062132\",\n \"0.6055589\",\n \"0.6045716\",\n \"0.60455453\",\n \"0.6043081\",\n \"0.6022775\",\n \"0.6022267\",\n \"0.60211986\",\n \"0.6007773\",\n \"0.6004294\",\n \"0.5982393\",\n \"0.5966404\",\n \"0.595726\",\n \"0.5956153\",\n \"0.5935539\",\n \"0.5934698\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7220615"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":20188,"cells":{"query":{"kind":"string","value":"Create a pyplot plot and save to buffer."},"document":{"kind":"string","value":"def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize=14)\n plt.ylabel(\"TPR\", fontsize=14)\n plt.title(\"ROC Curve\", fontsize=14)\n plot = plt.plot(fpr, tpr, linewidth=2)\n buf = io.BytesIO()\n plt.savefig(buf, format='jpeg')\n buf.seek(0)\n plt.close()\n # plt.show()\n return buf"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save_plot(self, ):\n pass","def save_plot(self):\r\n\t\t# Generate the plot\r\n\t\tself.generate_plot()\r\n\t\t# Create save directory\r\n\t\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\r\n\t\tif not path_exists(directory):\r\n\t\t\tmakedirs(directory)\r\n\t\t# Save image file\r\n\t\tself.fig.savefig(directory+str(self.universe.time))","def export_plot(plot, wight=600, height=400, path='./results/reports/', file_format='.svg'):\n name = ''.join(random.choice(ascii_lowercase) for _ in range(10)) + file_format\n pio.write_image(plot, path+name, width=wight, height=height)","def show_plot_in_new_figure(data, ylim=(-0.3, 0.3),\n to_save=False, fname=\"extractor_test_results/result.png\"):\n \n plt.figure(figsize = (30,10))\n plt.ylim(ylim)\n plt.plot(list(data), 'b', lw=1)\n plt.grid()\n if show_plots: \n plt.show()\n \n if to_save:\n plt.savefig(fname)","def save_plot(p, file_name, path='../static/images/'):\n p.output_backend = \"svg\"\n export_svgs(p, filename=path + file_name + '.svg')","def create_plot(self, name, kernel, domain):\n (domain, norm) = domain\n self.buffer_configuration[name] = self._init_plot_buffer({\n 'kernel': kernel,\n 'length': len(domain),\n 'norm': norm,\n })\n self.submit_domain(name, domain, 0)\n return self.buffer_configuration[name]","def __plot(name, x, y):\n import matplotlib.pyplot as plt\n\n plt.plot(x, y)\n plt.xlabel('elements')\n plt.ylabel('time (seconds)')\n plt.savefig(\"{}\".format(name))","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize=14)\n plt.ylabel(\"TPR\", fontsize=14)\n plt.title(\"ROC Curve\", fontsize=14)\n plot = plt.plot(fpr, tpr, linewidth=2)\n buf = io.BytesIO()\n plt.savefig(buf, format='jpeg')\n buf.seek(0)\n plt.close()\n return buf","def save_plot(name):\n plt.savefig(name)\n plt.clf()","def create_plot():\n\n fig, ax = plt.subplots()\n return fig, ax","def test_make_plot_custom(self):\n print(sys._getframe().f_code.co_name)\n try:\n x = np.arange(0,6)*300000\n y = np.arange(0,6)\n pp.make_plot(x,y,plot_type='c',plot_title='test',ylabel='test',xlabel='test',xticks=[0,2,4,6],yticks=[0,2,4,6])\n except Exception as e:\n raise\n plt.close('all')","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize = 14)\n plt.ylabel(\"TPR\", fontsize = 14)\n plt.title(\"ROC Curve\", fontsize = 14)\n plot = plt.plot(fpr, tpr, linewidth = 2)\n buf = io.BytesIO()\n plt.savefig(buf, format = 'jpeg')\n buf.seek(0)\n plt.close()\n\n return buf","def gen_plot(fpr, tpr):\n plt.figure()\n plt.xlabel(\"FPR\", fontsize = 14)\n plt.ylabel(\"TPR\", fontsize = 14)\n plt.title(\"ROC Curve\", fontsize = 14)\n plot = plt.plot(fpr, tpr, linewidth = 2)\n buf = io.BytesIO()\n plt.savefig(buf, format = 'jpeg')\n buf.seek(0)\n plt.close()\n\n return buf","def save_plot(data, fname=\"plot.pdf\", axis_labels=None, show_legend=True, \n plot_title=None, plot_suptitle=\"None\"): \n figure()\n if isinstance(data[0], list): # multiple curves\n for idx, curve in enumerate(data):\n plot(curve, label=str(idx+1))\n if show_legend: \n legend(loc=\"best\")\n else: # only one curve\n plot(data) \n if not axis_labels is None:\n xlabel(axis_labels[0])\n ylabel(axis_labels[1]) \n if not plot_title is None:\n title(plot_title) \n if not plot_suptitle is None:\n suptitle(plot_suptitle)\n savefig(fname)","def test_make_plot_ur(self):\n print(sys._getframe().f_code.co_name)\n try:\n x = np.arange(0,6)*300000\n y = np.arange(0,6)\n pp.make_plot(x,y,plot_type='ur')\n except Exception as e:\n raise\n plt.close('all')","def save_plot(vol_rms_diff, subj_num):\n plt.plot(vol_rms_diff)\n plot_path = '{0}/figures/subj{1}_vol_rms_diff.png'.format(REPO_HOME_PATH,\n subj_num)\n plt.savefig(plot_path)\n print('Saved {0}'.format(plot_path))","def createPlot(self, plotData=None, **kwargs):\n\t\treturn super().createPlot(plotData=plotData, **kwargs)","def plot(figure_or_data, show_link=True, link_text='Export to plot.ly',\n validate=True, output_type='file', include_plotlyjs=True,\n filename='temp-plot.html', auto_open=True, image=None,\n image_filename='plot_image', image_width=800, image_height=600):\n if output_type not in ['div', 'file']:\n raise ValueError(\n \"`output_type` argument must be 'div' or 'file'. \"\n \"You supplied `\" + output_type + \"``\")\n if not filename.endswith('.html') and output_type == 'file':\n warnings.warn(\n \"Your filename `\" + filename + \"` didn't end with .html. \"\n \"Adding .html to the end of your file.\")\n filename += '.html'\n\n config = {}\n config['showLink'] = show_link\n config['linkText'] = link_text\n\n plot_html, plotdivid, width, height = _plot_html(\n figure_or_data, config, validate,\n '100%', '100%', global_requirejs=False)\n\n resize_script = ''\n if width == '100%' or height == '100%':\n resize_script = (\n ''\n '<script type=\"text/javascript\">'\n 'window.removeEventListener(\"resize\");'\n 'window.addEventListener(\"resize\", function(){{'\n 'Plotly.Plots.resize(document.getElementById(\"{id}\"));}});'\n '</script>'\n ).format(id=plotdivid)\n\n if output_type == 'file':\n with open(filename, 'w') as f:\n if include_plotlyjs:\n plotly_js_script = ''.join([\n '<script type=\"text/javascript\">',\n get_plotlyjs(),\n '</script>',\n ])\n else:\n plotly_js_script = ''\n\n if image:\n if image not in __IMAGE_FORMATS:\n raise ValueError('The image parameter must be one of the '\n 'following: {}'.format(__IMAGE_FORMATS))\n # if the check passes then download script is injected.\n # write the download script:\n script = get_image_download_script('plot')\n script = script.format(format=image,\n width=image_width,\n height=image_height,\n filename=image_filename,\n plot_id=plotdivid)\n else:\n script = ''\n\n f.write(''.join([\n '<html>',\n '<head><meta charset=\"utf-8\" /></head>',\n '<body>',\n plotly_js_script,\n plot_html,\n resize_script,\n script,\n '</body>',\n '</html>']))\n\n url = 'file://' + os.path.abspath(filename)\n if auto_open:\n webbrowser.open(url)\n\n return url\n\n elif output_type == 'div':\n if include_plotlyjs:\n return ''.join([\n '<div>',\n '<script type=\"text/javascript\">',\n get_plotlyjs(),\n '</script>',\n plot_html,\n '</div>'\n ])\n else:\n return plot_html","def test_plot_save_figure(self):\n pname = os.path.join(\n self.datadir,\n 'monol_testA_E3-50_pds_rebin1.03' + HEN_FILE_EXTENSION)\n hen.plot.main([pname, '--noplot', '--figname',\n os.path.join(self.datadir,\n 'monol_testA_E3-50_pds_rebin1.03.png'),\n '-o', 'dummy.qdp'])","def save_plot_as_png(self):\n file_save_path = QFileDialog.getSaveFileName(self, 'Save Plot PNG', \"\", \"PNG (*.png)|*.png\")\n\n if file_save_path[0]:\n self.figure.savefig(file_save_path[0], bbox_inches='tight')\n QMessageBox.about(self, \"Success!\", \"Your plot has been saved as png image successfully.\")","def pyplot_visualize(self, plot):\n if self.graph_type == self.TYPE_PLOT:\n plot.plot(self.x_axis)\n elif self.graph_type == self.TYPE_SCATTER:\n plot.scatter(self.x_axis, self.y_axis)\n elif self.graph_type == self.TYPE_HISTOGRAM:\n plot.hist(self.x_axis, bins=self.bins)\n self.py_apply_limits(plot)\n self.py_apply_ticks(plot)","def generate_2D_plot(x, y, labels_dict, file_title, plot_title):\n fig = plt.figure()\n plt.plot(x, y)\n\n if labels_dict:\n plt.xlabel(labels_dict[\"x\"])\n plt.ylabel(labels_dict[\"y\"])\n if plot_title:\n plt.title(plot_title)\n\n plt.savefig(file_title)","def plot_to_file(file_prefix=None, file_suffix=None, **kwargs) -> str:\n file_prefix = file_prefix or 'plot'\n file_suffix = file_suffix or '.png'\n path = tempfile.mktemp(prefix='%s-' % file_prefix, suffix=file_suffix)\n plt.savefig(path, **kwargs)\n plt.close() # Else plt.show() happens automatically [sometimes: with plt.* but not with plotnine...]\n return path","def save_plot_as_image(self):\r\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\r\n bbox_inches='tight')","def save_figure(self, data):\n\n\t\tsizes = np.shape(data)\n\t\tfig = plt.figure()\n\t\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\n\t\tax = plt.Axes(fig, [0., 0., 1., 1.])\n\t\tax.set_axis_off()\n\t\tfig.add_axes(ax)\n\t\tax.imshow(data, \"gray\")\n\n\t\t#plt.show()\n\t\tself.plotfile = os.path.join('static', 'Figure' + '.png')\n\t\tplt.savefig(self.plotfile, dpi = sizes[1])","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n# plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def plot_to_image(figure):\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def save_plot(epoch_num, step, rewards, filepath):\n fig, ax = plt.subplots() \n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\n fig.savefig(filepath)\n plt.close(fig) # close the figure ","def make_plot(x,y):","def plot():\n pass","def test_make_plot_ui(self):\n print(sys._getframe().f_code.co_name)\n try:\n x = np.arange(0,6)*300000\n y = np.arange(0,6)\n pp.make_plot(x,y,plot_type='ui')\n except Exception as e:\n raise\n plt.close('all')","def save_plot(fig, fname, dir_name=None):\n dir_path = os.path.dirname(os.path.realpath(__file__))\n if dir_name is None:\n dir_name = 'plots'\n else:\n dir_name = os.path.join('plots', dir_name)\n fpath = os.path.join(dir_path, '../../../', dir_name)\n if not os.path.exists(fpath):\n os.mkdir(fpath)\n fig_name = fpath + \"/\" + fname\n fig.savefig(fname=fig_name)","def save_plot_for_figure(figure, file_name, path=None):\n file_extension = '.pdf'\n file_name += file_extension\n if path is not None:\n file_name = os.path.join(path, file_name)\n figure.savefig(file_name, dpi=300, bbox_inches='tight', transparent=True)","def plot_to_image(figure):\n\t# Save the plot to a PNG in memory.\n\tbuf = io.BytesIO()\n\tplt.savefig(buf, format='png')\n\t# Closing the figure prevents it from being displayed directly inside\n\t# the notebook.\n\tplt.close(figure)\n\tbuf.seek(0)\n\timage = PIL.Image.open(buf)\n\timage = transforms.ToTensor()(image)\n\treturn image","def export(self, path):\r\n # Save plot as png\r\n dt = m.get_instance().dt\r\n self.perception_history = m.get_instance().larvae[0].history\r\n t = np.arange(0,len(self.perception_history)*dt,dt)\r\n plt.plot(t,self.perception_history)\r\n plt.title('Perception History')\r\n plt.xlabel('Time (s)')\r\n plt.ylabel('Perception (uM)')\r\n\r\n plt.gca().set_aspect('equal', adjustable='box')\r\n plt.savefig(path + '.png')","def saveGraph(xval, yval, title = \"GRAPH\", xlabel=\"X AXIS\", ylabel=\"Y AXIS\", axisRng=None, style='bo', filename=\"graph.png\", clear=False):\n plt.plot(xval, yval, style)\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.title(title)\n if axisRng is not None:\n plt.axis(axisRng)\n plt.savefig(filename)\n if clear:\n plt.clf()","def _setup_plot(x: float, y: float) -> plt.figure:\n LOG.debug(\"Initializing plot.\")\n plt.ion()\n fig = plt.figure(figsize=(x, y), num=\"GlacierFlowModel\")\n fig.patch.set_facecolor(\"black\")\n return fig","def test_make_plot_log(self):\n print(sys._getframe().f_code.co_name)\n try:\n x = np.arange(0,6)*300000\n y = np.arange(0,6)\n pp.make_plot(x,y,plot_type='d',y_axis_type='log',xticks=[0,1,2,3], yticks=[0,1,2,3])\n except Exception as e:\n raise\n plt.close('all')","def createBlankPlot(self):\n\n fig = plt.figure(figsize=(8,6),dpi=80)\n fig.set_facecolor('#ededed')\n \n # Format plot\n ax = plt.subplot(111)\n \n fig.canvas.draw()\n \n return fig, ax","def create_figure(self) -> None:\n plt.ion()\n self.fig = plt.figure(1)\n self.axis = self.fig.add_subplot(111, xlim=(0, 1), ylim=(0, 1))\n self.axis.grid(True)\n plt.xticks(np.linspace(0, 1, self._param[\"n_v\"] + 1))\n plt.yticks(np.linspace(0, 1, self._param[\"n_v\"] + 1))\n a_plt, = self.axis.plot([], [], 'bx', markersize=5)\n l_plt, = self.axis.plot([], [], 'r.', markersize=15)\n self.plots = [a_plt, l_plt]","def generate_plots(type_, data, name, plots_location):\n plt.cla()\n plt.clf()\n plot_type = getattr(sns, type_)\n plot_ = plot_type(data)\n fig = plot_.get_figure()\n fig.savefig('{}/{}_{}.png'.format(plots_location, name, type_))","def draw_plot(self, data_x_axis, data_y_axis, label_x_axis, label_y_axis):\n\n # Flipped tells us whether to invert the current x, y axis\n self.figure.clear()\n\n # Fix for plot having cutoff text or labels\n self.figure.tight_layout()\n self.figure.subplots_adjust(left=0.1, right=0.9, bottom=0.3, top=0.9)\n\n self.figure.suptitle(self.plot_title)\n\n ax = self.figure.add_subplot(111)\n\n # Add another argument fontsize = 10 to change the fontsize of the labels\n ax.set_xlabel(label_x_axis)\n ax.set_ylabel(label_y_axis)\n\n ax.xaxis.set_major_locator(plt.MaxNLocator(10))\n ax.yaxis.set_major_locator(plt.MaxNLocator(10))\n\n if self.plotType == 1:\n ax.scatter(data_x_axis, data_y_axis)\n\n elif self.plotType == 2:\n # SMOOTH CURVE CURRENTLY WORKS ONLY WITH INTEGRAL VALUES\n # Smoothen the curve points\n try:\n T = data_x_axis\n power = data_y_axis\n\n xnew = np.linspace(T.min(), T.max(),\n 300) # 300 represents number of points to make between T.min and T.max\n\n spl = make_interp_spline(T, power, k=3) # BSpline object\n power_smooth = spl(xnew)\n ax.scatter(data_x_axis, data_y_axis)\n ax.plot(xnew, power_smooth, marker='o')\n except:\n # Switch to normal plot if the data is not purely numeric in which case a smooth curve is not possible\n ax.plot(data_x_axis, data_y_axis, marker='o')\n\n else:\n ax.plot(data_x_axis, data_y_axis)\n\n self.canvas.draw()\n # Enable the option as plot is now drawn\n self.action_save_plot_png.setEnabled(True)\n self.action_toolbar_save_plot_png.setEnabled(True)","def _plt_to_png(self):\n import matplotlib.pyplot as plt\n from io import BytesIO\n\n with BytesIO() as file_obj:\n plt.savefig(file_obj, format='png')\n plt.close() # supress plot output\n file_obj.seek(0)\n png = file_obj.read()\n return png","def plotData(data, xLabel, yLabel, plotTitle, save=False, saveName=None):\n fig, ax = plt.subplots()\n ax.plot(data)\n ax.set(xlabel=xLabel, ylabel=yLabel,\n title=plotTitle)\n ax.grid()\n if save:\n if saveName is not None:\n fig.savefig(saveName)\n else:\n fig.savefig(\"figure\")\n plt.show()","def PygletPlot(*args, **kwargs):\n\n from sympy.plotting.pygletplot.plot import PygletPlot\n return PygletPlot(*args, **kwargs)","def make_image(self, frame, filename, **kwds):\n p = plot.plot(frame, **kwds)\n p.save_image(filename)","def plot_to_image(figure):\n\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n plt.close(figure)\n buf.seek(0)\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n image = tf.expand_dims(image, 0)\n\n return image","def plot_pz(pz_inst):\n plt.figure()\n \n plt.plot(pz_inst.z_data, pz_inst.p_data)\n \n plt.savefig(\"pz_figure.png\")\n plt.close()","def plot_finalize():\n global figure\n global axes\n\n plot_refresh()\n plt.ioff()\n plt.show()\n\n figure, axes = None, None","def solution(u_0, pl=\"animation\",save=False):\n p = plot(u_0,pl)\n if save:\n if pl==\"animation\":\n p.save('animation.mp4')\n else:\n p.savefig('plot.png') \n \n return p","def plt_save(path):\n plt.grid()\n plt.tight_layout()\n plt.savefig(path)\n plt.close()","def generate_plot(chart: Chart) -> Figure:\n factory = ChartFactory(recipes=ChartService.get_supported_recipes(),\n data_frame_service=CommonServiceProvider.DataFrameService)\n plot = factory.create_object(document=chart)\n\n return plot","def plot_to_image(figure: plt.Figure, close_figure: bool = True) -> tf.Tensor:\n # Save the plot to a PNG in memory.\n buf = io.BytesIO()\n figure.savefig(buf, format='png')\n # Closing the figure prevents it from being displayed directly inside\n # the notebook.\n plt.close(figure)\n buf.seek(0)\n # Convert PNG buffer to TF image\n image = tf.image.decode_png(buf.getvalue(), channels=4)\n # Add the batch dimension\n image = tf.expand_dims(image, 0)\n return image","def on_save(self, event):\n file_choices = \"PNG (*.png)|*.png\"\n \n dlg = wx.FileDialog(\n self, \n message=\"Save plot as...\",\n defaultDir=os.getcwd(),\n defaultFile=\"plot.png\",\n wildcard=file_choices,\n style=wx.SAVE)\n \n if dlg.ShowModal() == wx.ID_OK:\n path = dlg.GetPath()\n self.canvas.print_figure(path, dpi=self.dpi)\n self.flash_status_message(\"Saved to %s\" % path)","def plot_blank(self):\n self.figure_bmp.SetBitmap(self.controller.plot_blank())","def plotone(x,y,xlabel,ylabel,filename):\n fig=plt.figure()\n ax = fig.add_subplot(111)\n ax.plot(x,y,linewidth=2.0)\n plt.ylabel(ylabel)\n plt.xlabel(xlabel)\n fig.savefig(filename)","def plot(metric1, metric2, label1, label2, save_location, id, batch_size):\n try: \n fig = plt.figure()\n plt.plot(metric1, label=label1)\n plt.plot(metric2, label=label2, linestyle='dashed')\n plt.legend()\n plt.xlabel('Epoch')\n plt.grid(linestyle='dotted')\n # plt.ylim(top=)\n # plt.show()\n plt.savefig(save_location + id + '_' + DRUM_INSTRUMENT + '_' + str(EPOCHS) + '_' + str(batch_size) + '.pdf')\n plt.clf()\n plt.cla()\n plt.close(fig=fig)\n except Exception as e:\n print('Failed to create plot: ', e)","def plot(data, interactive=False):\n if interactive:\n plt.ion()\n fig = plt.figure()\n fig.canvas.draw()\n image = call_imshow(data)\n else:\n fig = plt.figure()\n image = call_imshow(data)\n plt.show()\n return fig, image","def save(file_name):\n setup()\n plt.savefig(file_name)","def quick_plot_save(self, mode='png'):\n batch = self.meta['batch']\n cellid = self.meta['cellid']\n modelname = self.meta['modelname']\n\n fig = plt.figure(figsize=(8, 9))\n plot_set = []\n for idx, m in enumerate(self.modules):\n if m.auto_plot:\n plot_set.append(idx)\n \n for sp, idx in enumerate(plot_set):\n m=self.modules[idx]\n log.info(self.mod_names[idx])\n plt.subplot(len(plot_set), 1, sp+1)\n m.do_plot(m)\n \n if len(plot_set)<6:\n plt.tight_layout()\n\n filename = (\n sc.DIRECTORY_ROOT + \"nems_saved_images/batch{0}/{1}/{2}.{3}\"\n .format(batch, cellid, modelname, mode)\n )\n\n if AWS:\n s3 = boto3.resource('s3')\n key = filename[len(sc.DIRECTORY_ROOT):]\n fileobj = io.BytesIO()\n fig.savefig(fileobj, format=mode)\n fileobj.seek(0)\n s3.Object(sc.PRIMARY_BUCKET, key).put(Body=fileobj)\n # return (\"s3://\" + sc.PRIMARY_BUCKET + \"/\" + key)\n else:\n dr = (\n sc.DIRECTORY_ROOT\n + \"nems_saved_images/batch{0}/{1}/\".format(batch, cellid)\n )\n try:\n os.stat(dr)\n if os.path.isfile(filename):\n os.remove(filename)\n except BaseException:\n os.mkdir(dr)\n\n try:\n fig.savefig(filename)\n except Exception as e:\n log.warn(\"Bad file extension for figure or couldn't save\")\n raise e\n\n try:\n os.chmod(filename, 0o666)\n except Exception as e:\n log.warn(\"Couldn't modify file permissions for figure\")\n raise e\n\n return filename","def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\n plt.figure()\n\n #legacy beamprofile data is a 1-D array of the peak negative pressure\n if len(self.hydoutput.shape)<2:\n pnp = self.hydoutput\n else:\n sensitivity = hyd_calibration(self.cfreq)\n pnp = -1*np.min(self.hydoutput,1)/sensitivity\n\n if dbdown:\n pnp = 20.0*np.log10(pnp/np.max(pnp))\n else:\n pnp = pnp*1e-6\n\n figure1 = plt.plot(self.depth, pnp)\n #the latest beamprofile data should be a 2-D array of the hydrophone output\n plt.xlabel('Depth (mm)')\n if dbdown:\n plt.ylabel('Peak Negative Pressure (dB Max)')\n else:\n plt.ylabel('Peak Negative Pressure (MPa)')\n plt.title(self.txdr)\n if displayplt:\n plt.show()\n if saveplt:\n if savepath=='':\n #prompt for a save path using a default filename\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_depthprofile.png'\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\n plt.savefig(savepath)\n return figure1, savepath","def save_plot(self):\n self.pie_id = str(uuid.uuid4().hex)\n self.pie.savefig(str(self.pie_id + \"{}\").format(\".png\"))\n\n if self.verbose:\n print(\n \"Pie chart saved at \" + (\n str(self.pie_id + \"{}\").format(\".png\")))","def subplot_to_figure(self):\n if self.format is \"show\":\n plt.show()\n elif self.format is \"png\":\n plt.savefig(self.path + self.filename + \".png\", bbox_inches=\"tight\")","def report(cls):\n x = np.random.randint(low=1, high=11, size=50)\n y = x + np.random.randint(1, 5, size=x.size)\n fig, ax1 = plt.subplots()\n ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b')\n ax1.set_title('Scatter: $x$ versus $y$')\n ax1.set_xlabel('$x$')\n ax1.set_ylabel('$y$')\n buf = io.BytesIO()\n plt.savefig(buf, format='png')\n buf.seek(0)\n plt.show()\n return buf","def plot(self, job):\n # fill PlotJob with needed data if it doesn't exist\n # Plotter will look for the files it needs relative to the work directory\n # If this fails it will fall back to a baseline location if one was \n # Provided to cmake at the time this file was generated\n if job.dataPath == None :\n job.dataPath = \"Scenarios/\" + job.verificationDirectory + \"/baselines/\"\n \n if job.dataFile == None:\n job.dataFile = job.name + \"Results.zip\"\n \n if job.outputFilename==None:\n job.outputFilename=job.titleOverride+\".jpg\"\n \n if len(job.outputFilename.split(\".\"))==1:\n job.outputFilename+=\".jpg\"\n \n if job.imageWidth==None and job.imageHeight==None:\n job.imageWidth=1600\n job.imageHeight=800\n \n if not os.path.exists(job.dataPath):\n job.dataPath = os.path.join(job.basedir,job.dataPath)\n \n if not os.path.isfile(os.path.join(job.dataPath,job.dataFile)):\n job.dataPath = os.path.join(job.basedir,job.dataPath)\n \n if not job.fontSize:\n job.fontSize=22\n \n if not os.path.exists(os.path.dirname(job.outputDir)):\n os.mkdir(os.path.dirname(job.outputDir))\n \n self.drawgraph(job,os.path.join(job.dataPath,job.dataFile),os.path.join(job.outputDir,job.outputFilename))","def save_plot(results, ks, temp, name):\n\n # Draw plot\n plt.title(name)\n plt.xlabel(\"Sample size K\")\n plt.xscale('log')\n plt.ylabel(\"Average classification error\")\n # markers = ['-.co', '-ks', ':g^', '-ks', '-.ks', ':g', '-m', '-.y', '--r^']\n\n for series_label in results.keys():\n errs = [results[series_label][(k, temp)]['class_err'] for k in ks]\n plt.plot(ks, errs, label=series_label)\n\n # # Add padding so we can see the markers\n # xticks, xticklabels = plt.xticks()\n # xmin = (3 * xticks[0] - xticks[1]) / 2.\n # xmax = (3 * xticks[-1] - xticks[-2]) / 2.\n # plt.xlim(xmin, xmax)\n # plt.xticks(xticks)\n\n plt.legend(loc='best', ncol=3)\n file_id = time.time()\n plot_filename = \"plots/%s-%s.png\" % (name, file_id)\n plt.savefig(plot_filename)\n plt.gcf().clear()\n print(\"%s saved\\n\" % plot_filename)\n # TODO currently can't json.dumps, probably because of the (k, temp) tuple key\n # with open(\"plots/sourcedata_%s.json\" % file_id, 'w') as f:\n # print(json.dumps(results), file=f)","def show_plot(self):\r\n\t\tself.generate_plot()\r\n\t\tplt.show()","def _draw_plot(self, *args, **kw):\n # Simple compatibility with new-style rendering loop\n return self._draw_component(*args, **kw)","def _update_plot(self):\n\n self.T_ex[:-1] = self.T_ex[1:]\n self.T_ex[-1] = self.ensemble.T_ex\n self.plot_T_ex[0].set_ydata(self.T_ex)\n self.T_kin[:-1] = self.T_kin[1:]\n self.T_kin[-1] = self.ensemble.T_kin\n self.plot_T_kin[0].set_ydata(self.T_kin)\n self.canvas.draw()\n\n renderer = self.canvas.get_renderer()\n raw_data = renderer.tostring_rgb()\n surf = pygame.image.fromstring(raw_data,\n (self.plot_width, self.disp_height),\n \"RGB\")\n self.game_display.blit(surf, (self.disp_width, 0))","async def plot(self, new=False) -> None:\n self._logger.debug(\"running\")\n self.figure.clear()\n self.figure.set_tight_layout(True)\n num_plots = len(self._plots)\n axes = None\n for i in range(num_plots):\n plot = self._plots[i]\n name = plot[0]\n active = plot[2]\n if active:\n if i == 0:\n axes = self.figure.add_subplot(1, 1, 1)\n axes.tick_params(axis='x', labelrotation=30)\n axes.set_ylabel(name, color='#1f77b4')\n await sleep(.001)\n if not new:\n await create_task(self.plot_device_data(axes, name))\n else:\n alt_axes = axes.twinx()\n alt_axes.set_ylabel(name, color='#ff7f0e')\n alt_axes.tick_params(axis='y', labelcolor='#ff7f0e')\n alt_axes.set_yticks(np.arange(0, 6, step=1))\n await sleep(.001)\n if not new:\n await create_task(self.plot_device_data(alt_axes, name))\n\n if not new:\n self.add_vert_lines()\n await sleep(.001)\n self.figure.canvas.draw()\n self._logger.debug(\"done\")","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.canvas.draw()","def create_plot(self, options, row=0, column=0, rowspan=1, columnspan=1):\n print \"ImageWidgetMixin [CurveWidgetMixin] . create_plot\"\n self.plot_widget = BaseImageWidget(self, **options)\n self.plot_layout.addWidget(self.plot_widget,\n row, column, rowspan, columnspan)\n \n # Configuring plot manager\n self.add_plot(self.plot_widget.plot)\n self.add_panel(self.plot_widget.itemlist)\n self.add_panel(self.plot_widget.xcsw)\n self.add_panel(self.plot_widget.ycsw)\n self.add_panel(self.plot_widget.contrast)","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\n self.canvas.draw()","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\n self.canvas.draw()","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\n self.canvas.draw()","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\n self.canvas.draw()","def updatePlot(self):\n self.axes.clear()\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\n self.canvas.draw()","def scatterplot(X,Y,xlabel,ylabel,filename,outdir,name_mod):\n\tplt.clf()\n\tplt.scatter(X,Y)\n\tplt.xlabel(xlabel)\n\tplt.ylabel(ylabel)\n\tplt.savefig(outdir+filename + name_mod + \".png\")\n\tnp.savetxt(outdir+ xlabel + name_mod + \".npy\",x)\n\tnp.savetxt(outdir+ ylabel + name_mod + \".npy\",y)\n\treturn None","def add_plot(self, img_path, width):\n shutil.copy(img_path, f'{ReportGenerator.TEMP_FOLDER}/{hash(img_path)}.png')\n plot_template = self.templateEnv.get_template(f'{ReportGenerator.COMPONENTS_FOLDER}/plot.html')\n plot_output = plot_template.render(img_path=f'{hash(img_path)}.png', style=f\"'width:{width};'\")\n self.contents.append(plot_output)","def show_plot(points, save=False, name=\"plot\"):\n plt.figure()\n fig, ax = plt.subplots()\n # this locator puts ticks at regular intervals\n loc = ticker.MultipleLocator(base=0.2)\n ax.yaxis.set_major_locator(loc)\n plt.plot(points)\n if save:\n if not os.path.isdir(\"imgs\"):\n os.mkdir(\"imgs\")\n plt.savefig(\"imgs/\" + name + \".jpg\")\n plt.show()","def assemblePlot(self):\n self.clearPlot()\n self.axes = self.figure.add_subplot(111)\n\n # Reset handles\n self._fluxOverlayHandles = []\n self._magneticAxisHandle = None\n self._orbitHandles = []\n self._separatrixOverlayHandle = None\n self._wallCrossSectionOverlayHandle = None\n\n # Plot image\n self.plotEq()\n\n # Plot overlays\n self.plotOverlays()\n\n self.adjustAxes()","def makeplot(x, ys, labels, xlabel, ylabel, plainlines = False, figure = None,\\\r\n filename = None, sigmas = None, logy = False, logx = False):\r\n \r\n #initialise a pyplot figure if needed\r\n if figure is None:\r\n f = plt.figure()\r\n #add axis\r\n a = f.add_subplot(111)\r\n else:\r\n a = f.axes[0]\r\n \r\n #styles for plotted data\r\n styles = ['rx-','yx-','gx-','mx-','rx-']\r\n formats = ['rx','yx','gx','mx','rx']\r\n \r\n #plain line styles\r\n if plainlines:\r\n styles = ['k-','r-','g-','y-','m-']\r\n \r\n #plot . . .\r\n for i in range(len(ys)):\r\n a.plot(x, ys[i], styles[i], label = labels[i])\r\n if sigmas is not None:\r\n for i in range(len(ys)):\r\n a.errorbar(x, ys[i],yerr = sigmas[i], fmt = formats[i], elinewidth = 1,\\\r\n ecolor = 'black', capsize = 2) \r\n if logx:\r\n a.set_xscale('log')\r\n if logy:\r\n a.set_yscale('log')\r\n \r\n #set labels\r\n a.set_xlabel(xlabel)\r\n a.set_ylabel(ylabel)\r\n \r\n #add legend\r\n a.legend(loc = 'best')\r\n \r\n #save\r\n if filename is not None:\r\n f.savefig(filename+\".svg\")\r\n \r\n return f","def test_plot_npy(self, script_runner: ScriptRunner, tmp_path: Path) -> None:\n outfile = tmp_path.joinpath(\"projection.png\")\n logfile = tmp_path.joinpath(\"plot.log\")\n result = script_runner.run(\n \"qaa\",\n \"plot\",\n \"-i\",\n PROJNP,\n \"-o\",\n outfile.as_posix(),\n \"-l\",\n logfile.as_posix(),\n \"--pca\",\n \"--verbose\",\n )\n assert result.success\n assert logfile.exists()\n assert outfile.exists()\n assert outfile.stat().st_size > 0","def set_plot(self, plot):\n self.pw = plot\n self._setup_widget()","def _init_plot(self) -> None:\n\n # create a grayscale plot\n out = sys.stdout\n sys.stdout = open(\"/dev/null\", \"w\")\n hdu = self.image_generator.image(self.ra, self.dec)\n self.plot = aplpy.FITSFigure(hdu)\n self.plot.show_grayscale()\n self.plot.set_theme(\"publication\")\n sys.stdout = out\n\n # label for the position angle\n pa_string = \"PA = %.1f\" % self.mode_details.position_angle().to_value(u.deg)\n if self.mode_details.automated_position_angle():\n pa_string += \" (auto)\"\n self.draw_label(0.95, -0.05, pa_string, style=\"italic\", weight=\"bold\")\n\n # label for the title\n if self.title:\n self.draw_label(\n 0.5, 1.03, self.title, style=\"italic\", weight=\"bold\", size=\"large\"\n )\n\n # label for the image source\n self.draw_label(\n -0.05,\n -0.05,\n \"%s\" % self.image_generator.source(),\n style=\"italic\",\n weight=\"bold\",\n )\n\n # grid overlay\n self.plot.add_grid()\n self.plot.grid.set_alpha(0.2)\n self.plot.grid.set_color(\"b\")\n\n # indicate the RSS field of view\n self.draw_circle(self.ra, self.dec, 4.0 * u.arcmin, \"g\")\n self.draw_label(\n 0.79,\n 0.79,\n \"RSS\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"left\",\n color=(0, 0, 1),\n )\n\n # indicate the Salticam field of view\n self.draw_circle(self.ra, self.dec, 5.0 * u.arcmin, \"g\")\n self.draw_label(\n 0.86,\n 0.86,\n \"SCAM\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"left\",\n color=(0, 0, 1),\n )\n\n # labels for north and east direction\n self.draw_label(\n self.ra,\n self.dec + 4.8 * u.arcmin,\n \"N\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n color=(0, 0.5, 1),\n )\n self.draw_label(\n self.ra + 4.8 * u.arcmin / np.abs(np.cos(self.dec)),\n self.dec,\n \"E\",\n style=\"italic\",\n weight=\"bold\",\n size=\"large\",\n horizontalalignment=\"right\",\n color=(0, 0.5, 1),\n )\n\n # add cross hairs\n self.draw_centered_line(\n 0 * u.deg,\n 8 * u.arcmin,\n self.ra,\n self.dec,\n color=\"g\",\n linewidth=0.5,\n alpha=1.0,\n )\n self.draw_centered_line(\n 90 * u.deg,\n 8 * u.arcmin,\n self.ra,\n self.dec,\n color=\"g\",\n linewidth=0.5,\n alpha=1.0,\n )\n\n # label for the magnitude range and bandpass\n if self.magnitude_range:\n self._show_magnitudes()\n\n # add mode specific content\n if not self.basic_annotations:\n self.mode_details.annotate_finder_chart(self)","def _saveFig(self):\r\n # Save plot\r\n filenameG = self._vna.getDateFormatted() + \".png\"\r\n filenameG = \"Graphs/\" + filenameG \r\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\r\n plt.clf()","def plot_and_save(data, prefix, name):\n plt.figure()\n plt.hist(data)\n plt.title(name)\n plt.xlabel(\"Value\")\n plt.ylabel(\"Frequency\")\n plt.savefig(prefix + name + '.png')\n plt.close()","def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\n plt.figure()\n\n #legacy beamprofile data is a 1-D array of the peak negative pressure\n pnp = self.pnp\n\n if dbdown:\n pnp = 20.0*np.log10(pnp/np.max(pnp))\n else:\n pnp = pnp*1e-6\n\n if polarplt:\n figure1 = plt.polar(self.angle * np.pi / 180.0, pnp)\n else:\n figure1 = plt.plot(self.angle, pnp)\n #the latest beamprofile data should be a 2-D array of the hydrophone output\n plt.xlabel('Angle (degrees)')\n if dbdown:\n plt.ylabel('Peak Negative Pressure (dB Max)')\n else:\n plt.ylabel('Peak Negative Pressure (MPa)')\n plt.title(self.txdr)\n if displayplt:\n plt.show()\n if saveplt:\n if savepath=='':\n #prompt for a save path using a default filename\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_beamprofile.png'\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\n plt.savefig(savepath)\n return figure1, savepath","def demo():\n\n # A straightforward use of gnuplot. The `debug=1' switch is used\n # in these examples so that the commands that are sent to gnuplot\n # are also output on stderr.\n g = Gnuplot.Gnuplot(debug=1)\n g.title('A simple example') # (optional)\n g('set data style linespoints') # give gnuplot an arbitrary command\n # Plot a list of (x, y) pairs (tuples or a Numeric array would\n # also be OK):\n g.plot([[0,1.1], [1,5.8], [2,3.3], [3,4.2]])\n raw_input('Please press return to continue...\\n')\n\n g.reset()\n # Plot one dataset from an array and one via a gnuplot function;\n # also demonstrate the use of item-specific options:\n x = arange(10, typecode=Float)\n y1 = x**2\n # Notice how this plotitem is created here but used later? This\n # is convenient if the same dataset has to be plotted multiple\n # times. It is also more efficient because the data need only be\n # written to a temporary file once.\n d = Gnuplot.Data(x, y1,\n title='calculated by python',\n with='points 3 3')\n g.title('Data can be computed by python or gnuplot')\n g.xlabel('x')\n g.ylabel('x squared')\n # Plot a function alongside the Data PlotItem defined above:\n g.plot(Gnuplot.Func('x**2', title='calculated by gnuplot'), d)\n raw_input('Please press return to continue...\\n')\n\n # Save what we just plotted as a color postscript file.\n\n # With the enhanced postscript option, it is possible to show `x\n # squared' with a superscript (plus much, much more; see `help set\n # term postscript' in the gnuplot docs). If your gnuplot doesn't\n # support enhanced mode, set `enhanced=0' below.\n g.ylabel('x^2') # take advantage of enhanced postscript mode\n g.hardcopy('gp_test.ps', enhanced=1, color=1)\n print ('\\n******** Saved plot to postscript file \"gp_test.ps\" ********\\n')\n raw_input('Please press return to continue...\\n')\n\n g.reset()\n # Demonstrate a 3-d plot:\n # set up x and y values at which the function will be tabulated:\n x = arange(35)/2.0\n y = arange(30)/10.0 - 1.5\n # Make a 2-d array containing a function of x and y. First create\n # xm and ym which contain the x and y values in a matrix form that\n # can be `broadcast' into a matrix of the appropriate shape:\n xm = x[:,NewAxis]\n ym = y[NewAxis,:]\n m = (sin(xm) + 0.1*xm) - ym**2\n g('set parametric')\n g('set data style lines')\n g('set hidden')\n g('set contour base')\n g.title('An example of a surface plot')\n g.xlabel('x')\n g.ylabel('y')\n # The `binary=1' option would cause communication with gnuplot to\n # be in binary format, which is considerably faster and uses less\n # disk space. (This only works with the splot command due to\n # limitations of gnuplot.) `binary=1' is the default, but here we\n # disable binary because older versions of gnuplot don't allow\n # binary data. Change this to `binary=1' (or omit the binary\n # option) to get the advantage of binary format.\n g.splot(Gnuplot.GridData(m,x,y, binary=0))\n raw_input('Please press return to continue...\\n')\n\n # plot another function, but letting GridFunc tabulate its values\n # automatically. f could also be a lambda or a global function:\n def f(x,y):\n return 1.0 / (1 + 0.01 * x**2 + 0.5 * y**2)\n\n g.splot(Gnuplot.funcutils.compute_GridData(x,y, f, binary=0))\n raw_input('Please press return to continue...\\n')\n\n # Explicit delete shouldn't be necessary, but if you are having\n # trouble with temporary files being left behind, try uncommenting\n # the following:\n #del g, d","def export_plot(plot: Figure) -> TemplateResourcesData:\n template_resources = TemplateResourcesData()\n template_resources.js, template_resources.html = components(plot)\n\n return template_resources","def to_image(fig):\n fig.tight_layout(pad=1)\n fig.canvas.draw()\n image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\n image_from_plot = image_from_plot.reshape(\n fig.canvas.get_width_height()[::-1] + (3,))\n return image_from_plot","def plt_to_img(dummy: any = None, **kwargs) -> PIL.Image.Image:\n return PIL.Image.open(plot_to_file(**kwargs))","def show_save_plot(self, name=''):\n if self.save_plots:\n plt.savefig(os.path.join(self.out_folder, f'{name}.png'), dpi=300)\n plt.show()","def save_plot(fname, x, y, xlabel, ylabel, title):\n # plot details\n loss_fig = plt.figure(1)\n plt.plot(x, y, \"r-\", label=\"Train Loss\")\n plt.xlabel(xlabel)\n plt.ylabel(ylabel)\n plt.grid(True, which=\"major\", axis=\"both\", color=\"k\", ls=\"dotted\", lw=\"1.0\")\n plt.grid(True, which=\"minor\", axis=\"y\", color=\"k\", ls=\"dotted\", lw=\"0.5\")\n plt.minorticks_on()\n plt.title(title)\n\n # save and show\n loss_fig.tight_layout()\n loss_fig.savefig(fname + \".png\", bbox_inches=\"tight\", dpi=200)\n if args.show_loss_plot:\n plt.show()\n plt.close()","def save_plots(self, **plot_params):\n visualizer = BenchmarkSuiteVisualizer(self.logger, self._is_sweep, **plot_params)\n visualizer.save_reports()"],"string":"[\n \"def save_plot(self, ):\\n pass\",\n \"def save_plot(self):\\r\\n\\t\\t# Generate the plot\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\t# Create save directory\\r\\n\\t\\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\\r\\n\\t\\tif not path_exists(directory):\\r\\n\\t\\t\\tmakedirs(directory)\\r\\n\\t\\t# Save image file\\r\\n\\t\\tself.fig.savefig(directory+str(self.universe.time))\",\n \"def export_plot(plot, wight=600, height=400, path='./results/reports/', file_format='.svg'):\\n name = ''.join(random.choice(ascii_lowercase) for _ in range(10)) + file_format\\n pio.write_image(plot, path+name, width=wight, height=height)\",\n \"def show_plot_in_new_figure(data, ylim=(-0.3, 0.3),\\n to_save=False, fname=\\\"extractor_test_results/result.png\\\"):\\n \\n plt.figure(figsize = (30,10))\\n plt.ylim(ylim)\\n plt.plot(list(data), 'b', lw=1)\\n plt.grid()\\n if show_plots: \\n plt.show()\\n \\n if to_save:\\n plt.savefig(fname)\",\n \"def save_plot(p, file_name, path='../static/images/'):\\n p.output_backend = \\\"svg\\\"\\n export_svgs(p, filename=path + file_name + '.svg')\",\n \"def create_plot(self, name, kernel, domain):\\n (domain, norm) = domain\\n self.buffer_configuration[name] = self._init_plot_buffer({\\n 'kernel': kernel,\\n 'length': len(domain),\\n 'norm': norm,\\n })\\n self.submit_domain(name, domain, 0)\\n return self.buffer_configuration[name]\",\n \"def __plot(name, x, y):\\n import matplotlib.pyplot as plt\\n\\n plt.plot(x, y)\\n plt.xlabel('elements')\\n plt.ylabel('time (seconds)')\\n plt.savefig(\\\"{}\\\".format(name))\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize=14)\\n plt.ylabel(\\\"TPR\\\", fontsize=14)\\n plt.title(\\\"ROC Curve\\\", fontsize=14)\\n plot = plt.plot(fpr, tpr, linewidth=2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format='jpeg')\\n buf.seek(0)\\n plt.close()\\n return buf\",\n \"def save_plot(name):\\n plt.savefig(name)\\n plt.clf()\",\n \"def create_plot():\\n\\n fig, ax = plt.subplots()\\n return fig, ax\",\n \"def test_make_plot_custom(self):\\n print(sys._getframe().f_code.co_name)\\n try:\\n x = np.arange(0,6)*300000\\n y = np.arange(0,6)\\n pp.make_plot(x,y,plot_type='c',plot_title='test',ylabel='test',xlabel='test',xticks=[0,2,4,6],yticks=[0,2,4,6])\\n except Exception as e:\\n raise\\n plt.close('all')\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize = 14)\\n plt.ylabel(\\\"TPR\\\", fontsize = 14)\\n plt.title(\\\"ROC Curve\\\", fontsize = 14)\\n plot = plt.plot(fpr, tpr, linewidth = 2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format = 'jpeg')\\n buf.seek(0)\\n plt.close()\\n\\n return buf\",\n \"def gen_plot(fpr, tpr):\\n plt.figure()\\n plt.xlabel(\\\"FPR\\\", fontsize = 14)\\n plt.ylabel(\\\"TPR\\\", fontsize = 14)\\n plt.title(\\\"ROC Curve\\\", fontsize = 14)\\n plot = plt.plot(fpr, tpr, linewidth = 2)\\n buf = io.BytesIO()\\n plt.savefig(buf, format = 'jpeg')\\n buf.seek(0)\\n plt.close()\\n\\n return buf\",\n \"def save_plot(data, fname=\\\"plot.pdf\\\", axis_labels=None, show_legend=True, \\n plot_title=None, plot_suptitle=\\\"None\\\"): \\n figure()\\n if isinstance(data[0], list): # multiple curves\\n for idx, curve in enumerate(data):\\n plot(curve, label=str(idx+1))\\n if show_legend: \\n legend(loc=\\\"best\\\")\\n else: # only one curve\\n plot(data) \\n if not axis_labels is None:\\n xlabel(axis_labels[0])\\n ylabel(axis_labels[1]) \\n if not plot_title is None:\\n title(plot_title) \\n if not plot_suptitle is None:\\n suptitle(plot_suptitle)\\n savefig(fname)\",\n \"def test_make_plot_ur(self):\\n print(sys._getframe().f_code.co_name)\\n try:\\n x = np.arange(0,6)*300000\\n y = np.arange(0,6)\\n pp.make_plot(x,y,plot_type='ur')\\n except Exception as e:\\n raise\\n plt.close('all')\",\n \"def save_plot(vol_rms_diff, subj_num):\\n plt.plot(vol_rms_diff)\\n plot_path = '{0}/figures/subj{1}_vol_rms_diff.png'.format(REPO_HOME_PATH,\\n subj_num)\\n plt.savefig(plot_path)\\n print('Saved {0}'.format(plot_path))\",\n \"def createPlot(self, plotData=None, **kwargs):\\n\\t\\treturn super().createPlot(plotData=plotData, **kwargs)\",\n \"def plot(figure_or_data, show_link=True, link_text='Export to plot.ly',\\n validate=True, output_type='file', include_plotlyjs=True,\\n filename='temp-plot.html', auto_open=True, image=None,\\n image_filename='plot_image', image_width=800, image_height=600):\\n if output_type not in ['div', 'file']:\\n raise ValueError(\\n \\\"`output_type` argument must be 'div' or 'file'. \\\"\\n \\\"You supplied `\\\" + output_type + \\\"``\\\")\\n if not filename.endswith('.html') and output_type == 'file':\\n warnings.warn(\\n \\\"Your filename `\\\" + filename + \\\"` didn't end with .html. \\\"\\n \\\"Adding .html to the end of your file.\\\")\\n filename += '.html'\\n\\n config = {}\\n config['showLink'] = show_link\\n config['linkText'] = link_text\\n\\n plot_html, plotdivid, width, height = _plot_html(\\n figure_or_data, config, validate,\\n '100%', '100%', global_requirejs=False)\\n\\n resize_script = ''\\n if width == '100%' or height == '100%':\\n resize_script = (\\n ''\\n '<script type=\\\"text/javascript\\\">'\\n 'window.removeEventListener(\\\"resize\\\");'\\n 'window.addEventListener(\\\"resize\\\", function(){{'\\n 'Plotly.Plots.resize(document.getElementById(\\\"{id}\\\"));}});'\\n '</script>'\\n ).format(id=plotdivid)\\n\\n if output_type == 'file':\\n with open(filename, 'w') as f:\\n if include_plotlyjs:\\n plotly_js_script = ''.join([\\n '<script type=\\\"text/javascript\\\">',\\n get_plotlyjs(),\\n '</script>',\\n ])\\n else:\\n plotly_js_script = ''\\n\\n if image:\\n if image not in __IMAGE_FORMATS:\\n raise ValueError('The image parameter must be one of the '\\n 'following: {}'.format(__IMAGE_FORMATS))\\n # if the check passes then download script is injected.\\n # write the download script:\\n script = get_image_download_script('plot')\\n script = script.format(format=image,\\n width=image_width,\\n height=image_height,\\n filename=image_filename,\\n plot_id=plotdivid)\\n else:\\n script = ''\\n\\n f.write(''.join([\\n '<html>',\\n '<head><meta charset=\\\"utf-8\\\" /></head>',\\n '<body>',\\n plotly_js_script,\\n plot_html,\\n resize_script,\\n script,\\n '</body>',\\n '</html>']))\\n\\n url = 'file://' + os.path.abspath(filename)\\n if auto_open:\\n webbrowser.open(url)\\n\\n return url\\n\\n elif output_type == 'div':\\n if include_plotlyjs:\\n return ''.join([\\n '<div>',\\n '<script type=\\\"text/javascript\\\">',\\n get_plotlyjs(),\\n '</script>',\\n plot_html,\\n '</div>'\\n ])\\n else:\\n return plot_html\",\n \"def test_plot_save_figure(self):\\n pname = os.path.join(\\n self.datadir,\\n 'monol_testA_E3-50_pds_rebin1.03' + HEN_FILE_EXTENSION)\\n hen.plot.main([pname, '--noplot', '--figname',\\n os.path.join(self.datadir,\\n 'monol_testA_E3-50_pds_rebin1.03.png'),\\n '-o', 'dummy.qdp'])\",\n \"def save_plot_as_png(self):\\n file_save_path = QFileDialog.getSaveFileName(self, 'Save Plot PNG', \\\"\\\", \\\"PNG (*.png)|*.png\\\")\\n\\n if file_save_path[0]:\\n self.figure.savefig(file_save_path[0], bbox_inches='tight')\\n QMessageBox.about(self, \\\"Success!\\\", \\\"Your plot has been saved as png image successfully.\\\")\",\n \"def pyplot_visualize(self, plot):\\n if self.graph_type == self.TYPE_PLOT:\\n plot.plot(self.x_axis)\\n elif self.graph_type == self.TYPE_SCATTER:\\n plot.scatter(self.x_axis, self.y_axis)\\n elif self.graph_type == self.TYPE_HISTOGRAM:\\n plot.hist(self.x_axis, bins=self.bins)\\n self.py_apply_limits(plot)\\n self.py_apply_ticks(plot)\",\n \"def generate_2D_plot(x, y, labels_dict, file_title, plot_title):\\n fig = plt.figure()\\n plt.plot(x, y)\\n\\n if labels_dict:\\n plt.xlabel(labels_dict[\\\"x\\\"])\\n plt.ylabel(labels_dict[\\\"y\\\"])\\n if plot_title:\\n plt.title(plot_title)\\n\\n plt.savefig(file_title)\",\n \"def plot_to_file(file_prefix=None, file_suffix=None, **kwargs) -> str:\\n file_prefix = file_prefix or 'plot'\\n file_suffix = file_suffix or '.png'\\n path = tempfile.mktemp(prefix='%s-' % file_prefix, suffix=file_suffix)\\n plt.savefig(path, **kwargs)\\n plt.close() # Else plt.show() happens automatically [sometimes: with plt.* but not with plotnine...]\\n return path\",\n \"def save_plot_as_image(self):\\r\\n plt.savefig(ROOT_DIR + '/presentation/images/' + self.folder + '/' + self.generated_image_name + '.png',\\r\\n bbox_inches='tight')\",\n \"def save_figure(self, data):\\n\\n\\t\\tsizes = np.shape(data)\\n\\t\\tfig = plt.figure()\\n\\t\\tfig.set_size_inches(1, 1. * sizes[0]/sizes[1], forward = False)\\n\\t\\tax = plt.Axes(fig, [0., 0., 1., 1.])\\n\\t\\tax.set_axis_off()\\n\\t\\tfig.add_axes(ax)\\n\\t\\tax.imshow(data, \\\"gray\\\")\\n\\n\\t\\t#plt.show()\\n\\t\\tself.plotfile = os.path.join('static', 'Figure' + '.png')\\n\\t\\tplt.savefig(self.plotfile, dpi = sizes[1])\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n# plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def plot_to_image(figure):\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def save_plot(epoch_num, step, rewards, filepath):\\n fig, ax = plt.subplots() \\n ax.plot(range(0, epoch_num + 1, step), rewards)#,'.')\\n ax.plot(range(0, epoch_num + 1, step), np.ones(len(range(0, epoch_num + 1, step)))*rewards[0], 'r')\\n fig.savefig(filepath)\\n plt.close(fig) # close the figure \",\n \"def make_plot(x,y):\",\n \"def plot():\\n pass\",\n \"def test_make_plot_ui(self):\\n print(sys._getframe().f_code.co_name)\\n try:\\n x = np.arange(0,6)*300000\\n y = np.arange(0,6)\\n pp.make_plot(x,y,plot_type='ui')\\n except Exception as e:\\n raise\\n plt.close('all')\",\n \"def save_plot(fig, fname, dir_name=None):\\n dir_path = os.path.dirname(os.path.realpath(__file__))\\n if dir_name is None:\\n dir_name = 'plots'\\n else:\\n dir_name = os.path.join('plots', dir_name)\\n fpath = os.path.join(dir_path, '../../../', dir_name)\\n if not os.path.exists(fpath):\\n os.mkdir(fpath)\\n fig_name = fpath + \\\"/\\\" + fname\\n fig.savefig(fname=fig_name)\",\n \"def save_plot_for_figure(figure, file_name, path=None):\\n file_extension = '.pdf'\\n file_name += file_extension\\n if path is not None:\\n file_name = os.path.join(path, file_name)\\n figure.savefig(file_name, dpi=300, bbox_inches='tight', transparent=True)\",\n \"def plot_to_image(figure):\\n\\t# Save the plot to a PNG in memory.\\n\\tbuf = io.BytesIO()\\n\\tplt.savefig(buf, format='png')\\n\\t# Closing the figure prevents it from being displayed directly inside\\n\\t# the notebook.\\n\\tplt.close(figure)\\n\\tbuf.seek(0)\\n\\timage = PIL.Image.open(buf)\\n\\timage = transforms.ToTensor()(image)\\n\\treturn image\",\n \"def export(self, path):\\r\\n # Save plot as png\\r\\n dt = m.get_instance().dt\\r\\n self.perception_history = m.get_instance().larvae[0].history\\r\\n t = np.arange(0,len(self.perception_history)*dt,dt)\\r\\n plt.plot(t,self.perception_history)\\r\\n plt.title('Perception History')\\r\\n plt.xlabel('Time (s)')\\r\\n plt.ylabel('Perception (uM)')\\r\\n\\r\\n plt.gca().set_aspect('equal', adjustable='box')\\r\\n plt.savefig(path + '.png')\",\n \"def saveGraph(xval, yval, title = \\\"GRAPH\\\", xlabel=\\\"X AXIS\\\", ylabel=\\\"Y AXIS\\\", axisRng=None, style='bo', filename=\\\"graph.png\\\", clear=False):\\n plt.plot(xval, yval, style)\\n plt.xlabel(xlabel)\\n plt.ylabel(ylabel)\\n plt.title(title)\\n if axisRng is not None:\\n plt.axis(axisRng)\\n plt.savefig(filename)\\n if clear:\\n plt.clf()\",\n \"def _setup_plot(x: float, y: float) -> plt.figure:\\n LOG.debug(\\\"Initializing plot.\\\")\\n plt.ion()\\n fig = plt.figure(figsize=(x, y), num=\\\"GlacierFlowModel\\\")\\n fig.patch.set_facecolor(\\\"black\\\")\\n return fig\",\n \"def test_make_plot_log(self):\\n print(sys._getframe().f_code.co_name)\\n try:\\n x = np.arange(0,6)*300000\\n y = np.arange(0,6)\\n pp.make_plot(x,y,plot_type='d',y_axis_type='log',xticks=[0,1,2,3], yticks=[0,1,2,3])\\n except Exception as e:\\n raise\\n plt.close('all')\",\n \"def createBlankPlot(self):\\n\\n fig = plt.figure(figsize=(8,6),dpi=80)\\n fig.set_facecolor('#ededed')\\n \\n # Format plot\\n ax = plt.subplot(111)\\n \\n fig.canvas.draw()\\n \\n return fig, ax\",\n \"def create_figure(self) -> None:\\n plt.ion()\\n self.fig = plt.figure(1)\\n self.axis = self.fig.add_subplot(111, xlim=(0, 1), ylim=(0, 1))\\n self.axis.grid(True)\\n plt.xticks(np.linspace(0, 1, self._param[\\\"n_v\\\"] + 1))\\n plt.yticks(np.linspace(0, 1, self._param[\\\"n_v\\\"] + 1))\\n a_plt, = self.axis.plot([], [], 'bx', markersize=5)\\n l_plt, = self.axis.plot([], [], 'r.', markersize=15)\\n self.plots = [a_plt, l_plt]\",\n \"def generate_plots(type_, data, name, plots_location):\\n plt.cla()\\n plt.clf()\\n plot_type = getattr(sns, type_)\\n plot_ = plot_type(data)\\n fig = plot_.get_figure()\\n fig.savefig('{}/{}_{}.png'.format(plots_location, name, type_))\",\n \"def draw_plot(self, data_x_axis, data_y_axis, label_x_axis, label_y_axis):\\n\\n # Flipped tells us whether to invert the current x, y axis\\n self.figure.clear()\\n\\n # Fix for plot having cutoff text or labels\\n self.figure.tight_layout()\\n self.figure.subplots_adjust(left=0.1, right=0.9, bottom=0.3, top=0.9)\\n\\n self.figure.suptitle(self.plot_title)\\n\\n ax = self.figure.add_subplot(111)\\n\\n # Add another argument fontsize = 10 to change the fontsize of the labels\\n ax.set_xlabel(label_x_axis)\\n ax.set_ylabel(label_y_axis)\\n\\n ax.xaxis.set_major_locator(plt.MaxNLocator(10))\\n ax.yaxis.set_major_locator(plt.MaxNLocator(10))\\n\\n if self.plotType == 1:\\n ax.scatter(data_x_axis, data_y_axis)\\n\\n elif self.plotType == 2:\\n # SMOOTH CURVE CURRENTLY WORKS ONLY WITH INTEGRAL VALUES\\n # Smoothen the curve points\\n try:\\n T = data_x_axis\\n power = data_y_axis\\n\\n xnew = np.linspace(T.min(), T.max(),\\n 300) # 300 represents number of points to make between T.min and T.max\\n\\n spl = make_interp_spline(T, power, k=3) # BSpline object\\n power_smooth = spl(xnew)\\n ax.scatter(data_x_axis, data_y_axis)\\n ax.plot(xnew, power_smooth, marker='o')\\n except:\\n # Switch to normal plot if the data is not purely numeric in which case a smooth curve is not possible\\n ax.plot(data_x_axis, data_y_axis, marker='o')\\n\\n else:\\n ax.plot(data_x_axis, data_y_axis)\\n\\n self.canvas.draw()\\n # Enable the option as plot is now drawn\\n self.action_save_plot_png.setEnabled(True)\\n self.action_toolbar_save_plot_png.setEnabled(True)\",\n \"def _plt_to_png(self):\\n import matplotlib.pyplot as plt\\n from io import BytesIO\\n\\n with BytesIO() as file_obj:\\n plt.savefig(file_obj, format='png')\\n plt.close() # supress plot output\\n file_obj.seek(0)\\n png = file_obj.read()\\n return png\",\n \"def plotData(data, xLabel, yLabel, plotTitle, save=False, saveName=None):\\n fig, ax = plt.subplots()\\n ax.plot(data)\\n ax.set(xlabel=xLabel, ylabel=yLabel,\\n title=plotTitle)\\n ax.grid()\\n if save:\\n if saveName is not None:\\n fig.savefig(saveName)\\n else:\\n fig.savefig(\\\"figure\\\")\\n plt.show()\",\n \"def PygletPlot(*args, **kwargs):\\n\\n from sympy.plotting.pygletplot.plot import PygletPlot\\n return PygletPlot(*args, **kwargs)\",\n \"def make_image(self, frame, filename, **kwds):\\n p = plot.plot(frame, **kwds)\\n p.save_image(filename)\",\n \"def plot_to_image(figure):\\n\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n plt.close(figure)\\n buf.seek(0)\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n image = tf.expand_dims(image, 0)\\n\\n return image\",\n \"def plot_pz(pz_inst):\\n plt.figure()\\n \\n plt.plot(pz_inst.z_data, pz_inst.p_data)\\n \\n plt.savefig(\\\"pz_figure.png\\\")\\n plt.close()\",\n \"def plot_finalize():\\n global figure\\n global axes\\n\\n plot_refresh()\\n plt.ioff()\\n plt.show()\\n\\n figure, axes = None, None\",\n \"def solution(u_0, pl=\\\"animation\\\",save=False):\\n p = plot(u_0,pl)\\n if save:\\n if pl==\\\"animation\\\":\\n p.save('animation.mp4')\\n else:\\n p.savefig('plot.png') \\n \\n return p\",\n \"def plt_save(path):\\n plt.grid()\\n plt.tight_layout()\\n plt.savefig(path)\\n plt.close()\",\n \"def generate_plot(chart: Chart) -> Figure:\\n factory = ChartFactory(recipes=ChartService.get_supported_recipes(),\\n data_frame_service=CommonServiceProvider.DataFrameService)\\n plot = factory.create_object(document=chart)\\n\\n return plot\",\n \"def plot_to_image(figure: plt.Figure, close_figure: bool = True) -> tf.Tensor:\\n # Save the plot to a PNG in memory.\\n buf = io.BytesIO()\\n figure.savefig(buf, format='png')\\n # Closing the figure prevents it from being displayed directly inside\\n # the notebook.\\n plt.close(figure)\\n buf.seek(0)\\n # Convert PNG buffer to TF image\\n image = tf.image.decode_png(buf.getvalue(), channels=4)\\n # Add the batch dimension\\n image = tf.expand_dims(image, 0)\\n return image\",\n \"def on_save(self, event):\\n file_choices = \\\"PNG (*.png)|*.png\\\"\\n \\n dlg = wx.FileDialog(\\n self, \\n message=\\\"Save plot as...\\\",\\n defaultDir=os.getcwd(),\\n defaultFile=\\\"plot.png\\\",\\n wildcard=file_choices,\\n style=wx.SAVE)\\n \\n if dlg.ShowModal() == wx.ID_OK:\\n path = dlg.GetPath()\\n self.canvas.print_figure(path, dpi=self.dpi)\\n self.flash_status_message(\\\"Saved to %s\\\" % path)\",\n \"def plot_blank(self):\\n self.figure_bmp.SetBitmap(self.controller.plot_blank())\",\n \"def plotone(x,y,xlabel,ylabel,filename):\\n fig=plt.figure()\\n ax = fig.add_subplot(111)\\n ax.plot(x,y,linewidth=2.0)\\n plt.ylabel(ylabel)\\n plt.xlabel(xlabel)\\n fig.savefig(filename)\",\n \"def plot(metric1, metric2, label1, label2, save_location, id, batch_size):\\n try: \\n fig = plt.figure()\\n plt.plot(metric1, label=label1)\\n plt.plot(metric2, label=label2, linestyle='dashed')\\n plt.legend()\\n plt.xlabel('Epoch')\\n plt.grid(linestyle='dotted')\\n # plt.ylim(top=)\\n # plt.show()\\n plt.savefig(save_location + id + '_' + DRUM_INSTRUMENT + '_' + str(EPOCHS) + '_' + str(batch_size) + '.pdf')\\n plt.clf()\\n plt.cla()\\n plt.close(fig=fig)\\n except Exception as e:\\n print('Failed to create plot: ', e)\",\n \"def plot(data, interactive=False):\\n if interactive:\\n plt.ion()\\n fig = plt.figure()\\n fig.canvas.draw()\\n image = call_imshow(data)\\n else:\\n fig = plt.figure()\\n image = call_imshow(data)\\n plt.show()\\n return fig, image\",\n \"def save(file_name):\\n setup()\\n plt.savefig(file_name)\",\n \"def quick_plot_save(self, mode='png'):\\n batch = self.meta['batch']\\n cellid = self.meta['cellid']\\n modelname = self.meta['modelname']\\n\\n fig = plt.figure(figsize=(8, 9))\\n plot_set = []\\n for idx, m in enumerate(self.modules):\\n if m.auto_plot:\\n plot_set.append(idx)\\n \\n for sp, idx in enumerate(plot_set):\\n m=self.modules[idx]\\n log.info(self.mod_names[idx])\\n plt.subplot(len(plot_set), 1, sp+1)\\n m.do_plot(m)\\n \\n if len(plot_set)<6:\\n plt.tight_layout()\\n\\n filename = (\\n sc.DIRECTORY_ROOT + \\\"nems_saved_images/batch{0}/{1}/{2}.{3}\\\"\\n .format(batch, cellid, modelname, mode)\\n )\\n\\n if AWS:\\n s3 = boto3.resource('s3')\\n key = filename[len(sc.DIRECTORY_ROOT):]\\n fileobj = io.BytesIO()\\n fig.savefig(fileobj, format=mode)\\n fileobj.seek(0)\\n s3.Object(sc.PRIMARY_BUCKET, key).put(Body=fileobj)\\n # return (\\\"s3://\\\" + sc.PRIMARY_BUCKET + \\\"/\\\" + key)\\n else:\\n dr = (\\n sc.DIRECTORY_ROOT\\n + \\\"nems_saved_images/batch{0}/{1}/\\\".format(batch, cellid)\\n )\\n try:\\n os.stat(dr)\\n if os.path.isfile(filename):\\n os.remove(filename)\\n except BaseException:\\n os.mkdir(dr)\\n\\n try:\\n fig.savefig(filename)\\n except Exception as e:\\n log.warn(\\\"Bad file extension for figure or couldn't save\\\")\\n raise e\\n\\n try:\\n os.chmod(filename, 0o666)\\n except Exception as e:\\n log.warn(\\\"Couldn't modify file permissions for figure\\\")\\n raise e\\n\\n return filename\",\n \"def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\\n plt.figure()\\n\\n #legacy beamprofile data is a 1-D array of the peak negative pressure\\n if len(self.hydoutput.shape)<2:\\n pnp = self.hydoutput\\n else:\\n sensitivity = hyd_calibration(self.cfreq)\\n pnp = -1*np.min(self.hydoutput,1)/sensitivity\\n\\n if dbdown:\\n pnp = 20.0*np.log10(pnp/np.max(pnp))\\n else:\\n pnp = pnp*1e-6\\n\\n figure1 = plt.plot(self.depth, pnp)\\n #the latest beamprofile data should be a 2-D array of the hydrophone output\\n plt.xlabel('Depth (mm)')\\n if dbdown:\\n plt.ylabel('Peak Negative Pressure (dB Max)')\\n else:\\n plt.ylabel('Peak Negative Pressure (MPa)')\\n plt.title(self.txdr)\\n if displayplt:\\n plt.show()\\n if saveplt:\\n if savepath=='':\\n #prompt for a save path using a default filename\\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_depthprofile.png'\\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\\n plt.savefig(savepath)\\n return figure1, savepath\",\n \"def save_plot(self):\\n self.pie_id = str(uuid.uuid4().hex)\\n self.pie.savefig(str(self.pie_id + \\\"{}\\\").format(\\\".png\\\"))\\n\\n if self.verbose:\\n print(\\n \\\"Pie chart saved at \\\" + (\\n str(self.pie_id + \\\"{}\\\").format(\\\".png\\\")))\",\n \"def subplot_to_figure(self):\\n if self.format is \\\"show\\\":\\n plt.show()\\n elif self.format is \\\"png\\\":\\n plt.savefig(self.path + self.filename + \\\".png\\\", bbox_inches=\\\"tight\\\")\",\n \"def report(cls):\\n x = np.random.randint(low=1, high=11, size=50)\\n y = x + np.random.randint(1, 5, size=x.size)\\n fig, ax1 = plt.subplots()\\n ax1.scatter(x=x, y=y, marker='o', c='r', edgecolor='b')\\n ax1.set_title('Scatter: $x$ versus $y$')\\n ax1.set_xlabel('$x$')\\n ax1.set_ylabel('$y$')\\n buf = io.BytesIO()\\n plt.savefig(buf, format='png')\\n buf.seek(0)\\n plt.show()\\n return buf\",\n \"def plot(self, job):\\n # fill PlotJob with needed data if it doesn't exist\\n # Plotter will look for the files it needs relative to the work directory\\n # If this fails it will fall back to a baseline location if one was \\n # Provided to cmake at the time this file was generated\\n if job.dataPath == None :\\n job.dataPath = \\\"Scenarios/\\\" + job.verificationDirectory + \\\"/baselines/\\\"\\n \\n if job.dataFile == None:\\n job.dataFile = job.name + \\\"Results.zip\\\"\\n \\n if job.outputFilename==None:\\n job.outputFilename=job.titleOverride+\\\".jpg\\\"\\n \\n if len(job.outputFilename.split(\\\".\\\"))==1:\\n job.outputFilename+=\\\".jpg\\\"\\n \\n if job.imageWidth==None and job.imageHeight==None:\\n job.imageWidth=1600\\n job.imageHeight=800\\n \\n if not os.path.exists(job.dataPath):\\n job.dataPath = os.path.join(job.basedir,job.dataPath)\\n \\n if not os.path.isfile(os.path.join(job.dataPath,job.dataFile)):\\n job.dataPath = os.path.join(job.basedir,job.dataPath)\\n \\n if not job.fontSize:\\n job.fontSize=22\\n \\n if not os.path.exists(os.path.dirname(job.outputDir)):\\n os.mkdir(os.path.dirname(job.outputDir))\\n \\n self.drawgraph(job,os.path.join(job.dataPath,job.dataFile),os.path.join(job.outputDir,job.outputFilename))\",\n \"def save_plot(results, ks, temp, name):\\n\\n # Draw plot\\n plt.title(name)\\n plt.xlabel(\\\"Sample size K\\\")\\n plt.xscale('log')\\n plt.ylabel(\\\"Average classification error\\\")\\n # markers = ['-.co', '-ks', ':g^', '-ks', '-.ks', ':g', '-m', '-.y', '--r^']\\n\\n for series_label in results.keys():\\n errs = [results[series_label][(k, temp)]['class_err'] for k in ks]\\n plt.plot(ks, errs, label=series_label)\\n\\n # # Add padding so we can see the markers\\n # xticks, xticklabels = plt.xticks()\\n # xmin = (3 * xticks[0] - xticks[1]) / 2.\\n # xmax = (3 * xticks[-1] - xticks[-2]) / 2.\\n # plt.xlim(xmin, xmax)\\n # plt.xticks(xticks)\\n\\n plt.legend(loc='best', ncol=3)\\n file_id = time.time()\\n plot_filename = \\\"plots/%s-%s.png\\\" % (name, file_id)\\n plt.savefig(plot_filename)\\n plt.gcf().clear()\\n print(\\\"%s saved\\\\n\\\" % plot_filename)\\n # TODO currently can't json.dumps, probably because of the (k, temp) tuple key\\n # with open(\\\"plots/sourcedata_%s.json\\\" % file_id, 'w') as f:\\n # print(json.dumps(results), file=f)\",\n \"def show_plot(self):\\r\\n\\t\\tself.generate_plot()\\r\\n\\t\\tplt.show()\",\n \"def _draw_plot(self, *args, **kw):\\n # Simple compatibility with new-style rendering loop\\n return self._draw_component(*args, **kw)\",\n \"def _update_plot(self):\\n\\n self.T_ex[:-1] = self.T_ex[1:]\\n self.T_ex[-1] = self.ensemble.T_ex\\n self.plot_T_ex[0].set_ydata(self.T_ex)\\n self.T_kin[:-1] = self.T_kin[1:]\\n self.T_kin[-1] = self.ensemble.T_kin\\n self.plot_T_kin[0].set_ydata(self.T_kin)\\n self.canvas.draw()\\n\\n renderer = self.canvas.get_renderer()\\n raw_data = renderer.tostring_rgb()\\n surf = pygame.image.fromstring(raw_data,\\n (self.plot_width, self.disp_height),\\n \\\"RGB\\\")\\n self.game_display.blit(surf, (self.disp_width, 0))\",\n \"async def plot(self, new=False) -> None:\\n self._logger.debug(\\\"running\\\")\\n self.figure.clear()\\n self.figure.set_tight_layout(True)\\n num_plots = len(self._plots)\\n axes = None\\n for i in range(num_plots):\\n plot = self._plots[i]\\n name = plot[0]\\n active = plot[2]\\n if active:\\n if i == 0:\\n axes = self.figure.add_subplot(1, 1, 1)\\n axes.tick_params(axis='x', labelrotation=30)\\n axes.set_ylabel(name, color='#1f77b4')\\n await sleep(.001)\\n if not new:\\n await create_task(self.plot_device_data(axes, name))\\n else:\\n alt_axes = axes.twinx()\\n alt_axes.set_ylabel(name, color='#ff7f0e')\\n alt_axes.tick_params(axis='y', labelcolor='#ff7f0e')\\n alt_axes.set_yticks(np.arange(0, 6, step=1))\\n await sleep(.001)\\n if not new:\\n await create_task(self.plot_device_data(alt_axes, name))\\n\\n if not new:\\n self.add_vert_lines()\\n await sleep(.001)\\n self.figure.canvas.draw()\\n self._logger.debug(\\\"done\\\")\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.canvas.draw()\",\n \"def create_plot(self, options, row=0, column=0, rowspan=1, columnspan=1):\\n print \\\"ImageWidgetMixin [CurveWidgetMixin] . create_plot\\\"\\n self.plot_widget = BaseImageWidget(self, **options)\\n self.plot_layout.addWidget(self.plot_widget,\\n row, column, rowspan, columnspan)\\n \\n # Configuring plot manager\\n self.add_plot(self.plot_widget.plot)\\n self.add_panel(self.plot_widget.itemlist)\\n self.add_panel(self.plot_widget.xcsw)\\n self.add_panel(self.plot_widget.ycsw)\\n self.add_panel(self.plot_widget.contrast)\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\\n self.canvas.draw()\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\\n self.canvas.draw()\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\\n self.canvas.draw()\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\\n self.canvas.draw()\",\n \"def updatePlot(self):\\n self.axes.clear()\\n self.axes.plot(self.data[0], self.data[1], linestyle='-', color='gray')\\n self.axes.plot(self.data[0], self.data[2], linestyle='-', color='blue')\\n self.axes.plot(self.data[0], self.data[3], linestyle='-', color='darkgreen')\\n self.canvas.draw()\",\n \"def scatterplot(X,Y,xlabel,ylabel,filename,outdir,name_mod):\\n\\tplt.clf()\\n\\tplt.scatter(X,Y)\\n\\tplt.xlabel(xlabel)\\n\\tplt.ylabel(ylabel)\\n\\tplt.savefig(outdir+filename + name_mod + \\\".png\\\")\\n\\tnp.savetxt(outdir+ xlabel + name_mod + \\\".npy\\\",x)\\n\\tnp.savetxt(outdir+ ylabel + name_mod + \\\".npy\\\",y)\\n\\treturn None\",\n \"def add_plot(self, img_path, width):\\n shutil.copy(img_path, f'{ReportGenerator.TEMP_FOLDER}/{hash(img_path)}.png')\\n plot_template = self.templateEnv.get_template(f'{ReportGenerator.COMPONENTS_FOLDER}/plot.html')\\n plot_output = plot_template.render(img_path=f'{hash(img_path)}.png', style=f\\\"'width:{width};'\\\")\\n self.contents.append(plot_output)\",\n \"def show_plot(points, save=False, name=\\\"plot\\\"):\\n plt.figure()\\n fig, ax = plt.subplots()\\n # this locator puts ticks at regular intervals\\n loc = ticker.MultipleLocator(base=0.2)\\n ax.yaxis.set_major_locator(loc)\\n plt.plot(points)\\n if save:\\n if not os.path.isdir(\\\"imgs\\\"):\\n os.mkdir(\\\"imgs\\\")\\n plt.savefig(\\\"imgs/\\\" + name + \\\".jpg\\\")\\n plt.show()\",\n \"def assemblePlot(self):\\n self.clearPlot()\\n self.axes = self.figure.add_subplot(111)\\n\\n # Reset handles\\n self._fluxOverlayHandles = []\\n self._magneticAxisHandle = None\\n self._orbitHandles = []\\n self._separatrixOverlayHandle = None\\n self._wallCrossSectionOverlayHandle = None\\n\\n # Plot image\\n self.plotEq()\\n\\n # Plot overlays\\n self.plotOverlays()\\n\\n self.adjustAxes()\",\n \"def makeplot(x, ys, labels, xlabel, ylabel, plainlines = False, figure = None,\\\\\\r\\n filename = None, sigmas = None, logy = False, logx = False):\\r\\n \\r\\n #initialise a pyplot figure if needed\\r\\n if figure is None:\\r\\n f = plt.figure()\\r\\n #add axis\\r\\n a = f.add_subplot(111)\\r\\n else:\\r\\n a = f.axes[0]\\r\\n \\r\\n #styles for plotted data\\r\\n styles = ['rx-','yx-','gx-','mx-','rx-']\\r\\n formats = ['rx','yx','gx','mx','rx']\\r\\n \\r\\n #plain line styles\\r\\n if plainlines:\\r\\n styles = ['k-','r-','g-','y-','m-']\\r\\n \\r\\n #plot . . .\\r\\n for i in range(len(ys)):\\r\\n a.plot(x, ys[i], styles[i], label = labels[i])\\r\\n if sigmas is not None:\\r\\n for i in range(len(ys)):\\r\\n a.errorbar(x, ys[i],yerr = sigmas[i], fmt = formats[i], elinewidth = 1,\\\\\\r\\n ecolor = 'black', capsize = 2) \\r\\n if logx:\\r\\n a.set_xscale('log')\\r\\n if logy:\\r\\n a.set_yscale('log')\\r\\n \\r\\n #set labels\\r\\n a.set_xlabel(xlabel)\\r\\n a.set_ylabel(ylabel)\\r\\n \\r\\n #add legend\\r\\n a.legend(loc = 'best')\\r\\n \\r\\n #save\\r\\n if filename is not None:\\r\\n f.savefig(filename+\\\".svg\\\")\\r\\n \\r\\n return f\",\n \"def test_plot_npy(self, script_runner: ScriptRunner, tmp_path: Path) -> None:\\n outfile = tmp_path.joinpath(\\\"projection.png\\\")\\n logfile = tmp_path.joinpath(\\\"plot.log\\\")\\n result = script_runner.run(\\n \\\"qaa\\\",\\n \\\"plot\\\",\\n \\\"-i\\\",\\n PROJNP,\\n \\\"-o\\\",\\n outfile.as_posix(),\\n \\\"-l\\\",\\n logfile.as_posix(),\\n \\\"--pca\\\",\\n \\\"--verbose\\\",\\n )\\n assert result.success\\n assert logfile.exists()\\n assert outfile.exists()\\n assert outfile.stat().st_size > 0\",\n \"def set_plot(self, plot):\\n self.pw = plot\\n self._setup_widget()\",\n \"def _init_plot(self) -> None:\\n\\n # create a grayscale plot\\n out = sys.stdout\\n sys.stdout = open(\\\"/dev/null\\\", \\\"w\\\")\\n hdu = self.image_generator.image(self.ra, self.dec)\\n self.plot = aplpy.FITSFigure(hdu)\\n self.plot.show_grayscale()\\n self.plot.set_theme(\\\"publication\\\")\\n sys.stdout = out\\n\\n # label for the position angle\\n pa_string = \\\"PA = %.1f\\\" % self.mode_details.position_angle().to_value(u.deg)\\n if self.mode_details.automated_position_angle():\\n pa_string += \\\" (auto)\\\"\\n self.draw_label(0.95, -0.05, pa_string, style=\\\"italic\\\", weight=\\\"bold\\\")\\n\\n # label for the title\\n if self.title:\\n self.draw_label(\\n 0.5, 1.03, self.title, style=\\\"italic\\\", weight=\\\"bold\\\", size=\\\"large\\\"\\n )\\n\\n # label for the image source\\n self.draw_label(\\n -0.05,\\n -0.05,\\n \\\"%s\\\" % self.image_generator.source(),\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n )\\n\\n # grid overlay\\n self.plot.add_grid()\\n self.plot.grid.set_alpha(0.2)\\n self.plot.grid.set_color(\\\"b\\\")\\n\\n # indicate the RSS field of view\\n self.draw_circle(self.ra, self.dec, 4.0 * u.arcmin, \\\"g\\\")\\n self.draw_label(\\n 0.79,\\n 0.79,\\n \\\"RSS\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"left\\\",\\n color=(0, 0, 1),\\n )\\n\\n # indicate the Salticam field of view\\n self.draw_circle(self.ra, self.dec, 5.0 * u.arcmin, \\\"g\\\")\\n self.draw_label(\\n 0.86,\\n 0.86,\\n \\\"SCAM\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"left\\\",\\n color=(0, 0, 1),\\n )\\n\\n # labels for north and east direction\\n self.draw_label(\\n self.ra,\\n self.dec + 4.8 * u.arcmin,\\n \\\"N\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n color=(0, 0.5, 1),\\n )\\n self.draw_label(\\n self.ra + 4.8 * u.arcmin / np.abs(np.cos(self.dec)),\\n self.dec,\\n \\\"E\\\",\\n style=\\\"italic\\\",\\n weight=\\\"bold\\\",\\n size=\\\"large\\\",\\n horizontalalignment=\\\"right\\\",\\n color=(0, 0.5, 1),\\n )\\n\\n # add cross hairs\\n self.draw_centered_line(\\n 0 * u.deg,\\n 8 * u.arcmin,\\n self.ra,\\n self.dec,\\n color=\\\"g\\\",\\n linewidth=0.5,\\n alpha=1.0,\\n )\\n self.draw_centered_line(\\n 90 * u.deg,\\n 8 * u.arcmin,\\n self.ra,\\n self.dec,\\n color=\\\"g\\\",\\n linewidth=0.5,\\n alpha=1.0,\\n )\\n\\n # label for the magnitude range and bandpass\\n if self.magnitude_range:\\n self._show_magnitudes()\\n\\n # add mode specific content\\n if not self.basic_annotations:\\n self.mode_details.annotate_finder_chart(self)\",\n \"def _saveFig(self):\\r\\n # Save plot\\r\\n filenameG = self._vna.getDateFormatted() + \\\".png\\\"\\r\\n filenameG = \\\"Graphs/\\\" + filenameG \\r\\n plt.savefig(filenameG) # Plot saved in directory named Graphs located in same directory as pyTekVNA\\r\\n plt.clf()\",\n \"def plot_and_save(data, prefix, name):\\n plt.figure()\\n plt.hist(data)\\n plt.title(name)\\n plt.xlabel(\\\"Value\\\")\\n plt.ylabel(\\\"Frequency\\\")\\n plt.savefig(prefix + name + '.png')\\n plt.close()\",\n \"def plot(self,displayplt = True,saveplt = False,savepath='',polarplt=True, dbdown = False):\\n plt.figure()\\n\\n #legacy beamprofile data is a 1-D array of the peak negative pressure\\n pnp = self.pnp\\n\\n if dbdown:\\n pnp = 20.0*np.log10(pnp/np.max(pnp))\\n else:\\n pnp = pnp*1e-6\\n\\n if polarplt:\\n figure1 = plt.polar(self.angle * np.pi / 180.0, pnp)\\n else:\\n figure1 = plt.plot(self.angle, pnp)\\n #the latest beamprofile data should be a 2-D array of the hydrophone output\\n plt.xlabel('Angle (degrees)')\\n if dbdown:\\n plt.ylabel('Peak Negative Pressure (dB Max)')\\n else:\\n plt.ylabel('Peak Negative Pressure (MPa)')\\n plt.title(self.txdr)\\n if displayplt:\\n plt.show()\\n if saveplt:\\n if savepath=='':\\n #prompt for a save path using a default filename\\n defaultfn = self.txdr+'_'+self.collectiondate+'_'+self.collectiontime+'_beamprofile.png'\\n savepath = tkinter.filedialog.asksaveasfilename(initialfile=defaultfn, defaultextension='.png')\\n plt.savefig(savepath)\\n return figure1, savepath\",\n \"def demo():\\n\\n # A straightforward use of gnuplot. The `debug=1' switch is used\\n # in these examples so that the commands that are sent to gnuplot\\n # are also output on stderr.\\n g = Gnuplot.Gnuplot(debug=1)\\n g.title('A simple example') # (optional)\\n g('set data style linespoints') # give gnuplot an arbitrary command\\n # Plot a list of (x, y) pairs (tuples or a Numeric array would\\n # also be OK):\\n g.plot([[0,1.1], [1,5.8], [2,3.3], [3,4.2]])\\n raw_input('Please press return to continue...\\\\n')\\n\\n g.reset()\\n # Plot one dataset from an array and one via a gnuplot function;\\n # also demonstrate the use of item-specific options:\\n x = arange(10, typecode=Float)\\n y1 = x**2\\n # Notice how this plotitem is created here but used later? This\\n # is convenient if the same dataset has to be plotted multiple\\n # times. It is also more efficient because the data need only be\\n # written to a temporary file once.\\n d = Gnuplot.Data(x, y1,\\n title='calculated by python',\\n with='points 3 3')\\n g.title('Data can be computed by python or gnuplot')\\n g.xlabel('x')\\n g.ylabel('x squared')\\n # Plot a function alongside the Data PlotItem defined above:\\n g.plot(Gnuplot.Func('x**2', title='calculated by gnuplot'), d)\\n raw_input('Please press return to continue...\\\\n')\\n\\n # Save what we just plotted as a color postscript file.\\n\\n # With the enhanced postscript option, it is possible to show `x\\n # squared' with a superscript (plus much, much more; see `help set\\n # term postscript' in the gnuplot docs). If your gnuplot doesn't\\n # support enhanced mode, set `enhanced=0' below.\\n g.ylabel('x^2') # take advantage of enhanced postscript mode\\n g.hardcopy('gp_test.ps', enhanced=1, color=1)\\n print ('\\\\n******** Saved plot to postscript file \\\"gp_test.ps\\\" ********\\\\n')\\n raw_input('Please press return to continue...\\\\n')\\n\\n g.reset()\\n # Demonstrate a 3-d plot:\\n # set up x and y values at which the function will be tabulated:\\n x = arange(35)/2.0\\n y = arange(30)/10.0 - 1.5\\n # Make a 2-d array containing a function of x and y. First create\\n # xm and ym which contain the x and y values in a matrix form that\\n # can be `broadcast' into a matrix of the appropriate shape:\\n xm = x[:,NewAxis]\\n ym = y[NewAxis,:]\\n m = (sin(xm) + 0.1*xm) - ym**2\\n g('set parametric')\\n g('set data style lines')\\n g('set hidden')\\n g('set contour base')\\n g.title('An example of a surface plot')\\n g.xlabel('x')\\n g.ylabel('y')\\n # The `binary=1' option would cause communication with gnuplot to\\n # be in binary format, which is considerably faster and uses less\\n # disk space. (This only works with the splot command due to\\n # limitations of gnuplot.) `binary=1' is the default, but here we\\n # disable binary because older versions of gnuplot don't allow\\n # binary data. Change this to `binary=1' (or omit the binary\\n # option) to get the advantage of binary format.\\n g.splot(Gnuplot.GridData(m,x,y, binary=0))\\n raw_input('Please press return to continue...\\\\n')\\n\\n # plot another function, but letting GridFunc tabulate its values\\n # automatically. f could also be a lambda or a global function:\\n def f(x,y):\\n return 1.0 / (1 + 0.01 * x**2 + 0.5 * y**2)\\n\\n g.splot(Gnuplot.funcutils.compute_GridData(x,y, f, binary=0))\\n raw_input('Please press return to continue...\\\\n')\\n\\n # Explicit delete shouldn't be necessary, but if you are having\\n # trouble with temporary files being left behind, try uncommenting\\n # the following:\\n #del g, d\",\n \"def export_plot(plot: Figure) -> TemplateResourcesData:\\n template_resources = TemplateResourcesData()\\n template_resources.js, template_resources.html = components(plot)\\n\\n return template_resources\",\n \"def to_image(fig):\\n fig.tight_layout(pad=1)\\n fig.canvas.draw()\\n image_from_plot = np.frombuffer(fig.canvas.tostring_rgb(), dtype=np.uint8)\\n image_from_plot = image_from_plot.reshape(\\n fig.canvas.get_width_height()[::-1] + (3,))\\n return image_from_plot\",\n \"def plt_to_img(dummy: any = None, **kwargs) -> PIL.Image.Image:\\n return PIL.Image.open(plot_to_file(**kwargs))\",\n \"def show_save_plot(self, name=''):\\n if self.save_plots:\\n plt.savefig(os.path.join(self.out_folder, f'{name}.png'), dpi=300)\\n plt.show()\",\n \"def save_plot(fname, x, y, xlabel, ylabel, title):\\n # plot details\\n loss_fig = plt.figure(1)\\n plt.plot(x, y, \\\"r-\\\", label=\\\"Train Loss\\\")\\n plt.xlabel(xlabel)\\n plt.ylabel(ylabel)\\n plt.grid(True, which=\\\"major\\\", axis=\\\"both\\\", color=\\\"k\\\", ls=\\\"dotted\\\", lw=\\\"1.0\\\")\\n plt.grid(True, which=\\\"minor\\\", axis=\\\"y\\\", color=\\\"k\\\", ls=\\\"dotted\\\", lw=\\\"0.5\\\")\\n plt.minorticks_on()\\n plt.title(title)\\n\\n # save and show\\n loss_fig.tight_layout()\\n loss_fig.savefig(fname + \\\".png\\\", bbox_inches=\\\"tight\\\", dpi=200)\\n if args.show_loss_plot:\\n plt.show()\\n plt.close()\",\n \"def save_plots(self, **plot_params):\\n visualizer = BenchmarkSuiteVisualizer(self.logger, self._is_sweep, **plot_params)\\n visualizer.save_reports()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6640928","0.63603246","0.6227816","0.6167168","0.61360306","0.6119261","0.6099436","0.6096821","0.60925245","0.60660166","0.60238034","0.60147","0.60147","0.60105187","0.6010414","0.5986429","0.5986346","0.5965323","0.59541225","0.59522265","0.59299445","0.5922082","0.5921853","0.59129125","0.5885862","0.58835465","0.5883257","0.58773637","0.58773637","0.58773637","0.58760995","0.58760995","0.58711416","0.58682853","0.58673","0.58334804","0.5811175","0.58009976","0.57996356","0.57957107","0.57876164","0.5784643","0.5783906","0.57834","0.57687765","0.5765877","0.5744971","0.5743151","0.5732592","0.57265735","0.5726015","0.5708283","0.5708079","0.5700058","0.56951886","0.56901175","0.5676879","0.56719846","0.56652534","0.563617","0.563405","0.56335986","0.5631993","0.5627647","0.56169474","0.56088203","0.56061506","0.5586529","0.5575271","0.5574201","0.5568899","0.5568475","0.55588996","0.55531776","0.55429244","0.55415004","0.55319935","0.5530202","0.5530202","0.5530202","0.5530202","0.5530202","0.5528215","0.5524888","0.55248815","0.5523495","0.55234385","0.5521892","0.5519663","0.5515244","0.5504775","0.54994005","0.5478917","0.54777306","0.5475751","0.5474988","0.54749507","0.54743916","0.54737425","0.5473068"],"string":"[\n \"0.6640928\",\n \"0.63603246\",\n \"0.6227816\",\n \"0.6167168\",\n \"0.61360306\",\n \"0.6119261\",\n \"0.6099436\",\n \"0.6096821\",\n \"0.60925245\",\n \"0.60660166\",\n \"0.60238034\",\n \"0.60147\",\n \"0.60147\",\n \"0.60105187\",\n \"0.6010414\",\n \"0.5986429\",\n \"0.5986346\",\n \"0.5965323\",\n \"0.59541225\",\n \"0.59522265\",\n \"0.59299445\",\n \"0.5922082\",\n \"0.5921853\",\n \"0.59129125\",\n \"0.5885862\",\n \"0.58835465\",\n \"0.5883257\",\n \"0.58773637\",\n \"0.58773637\",\n \"0.58773637\",\n \"0.58760995\",\n \"0.58760995\",\n \"0.58711416\",\n \"0.58682853\",\n \"0.58673\",\n \"0.58334804\",\n \"0.5811175\",\n \"0.58009976\",\n \"0.57996356\",\n \"0.57957107\",\n \"0.57876164\",\n \"0.5784643\",\n \"0.5783906\",\n \"0.57834\",\n \"0.57687765\",\n \"0.5765877\",\n \"0.5744971\",\n \"0.5743151\",\n \"0.5732592\",\n \"0.57265735\",\n \"0.5726015\",\n \"0.5708283\",\n \"0.5708079\",\n \"0.5700058\",\n \"0.56951886\",\n \"0.56901175\",\n \"0.5676879\",\n \"0.56719846\",\n \"0.56652534\",\n \"0.563617\",\n \"0.563405\",\n \"0.56335986\",\n \"0.5631993\",\n \"0.5627647\",\n \"0.56169474\",\n \"0.56088203\",\n \"0.56061506\",\n \"0.5586529\",\n \"0.5575271\",\n \"0.5574201\",\n \"0.5568899\",\n \"0.5568475\",\n \"0.55588996\",\n \"0.55531776\",\n \"0.55429244\",\n \"0.55415004\",\n \"0.55319935\",\n \"0.5530202\",\n \"0.5530202\",\n \"0.5530202\",\n \"0.5530202\",\n \"0.5530202\",\n \"0.5528215\",\n \"0.5524888\",\n \"0.55248815\",\n \"0.5523495\",\n \"0.55234385\",\n \"0.5521892\",\n \"0.5519663\",\n \"0.5515244\",\n \"0.5504775\",\n \"0.54994005\",\n \"0.5478917\",\n \"0.54777306\",\n \"0.5475751\",\n \"0.5474988\",\n \"0.54749507\",\n \"0.54743916\",\n \"0.54737425\",\n \"0.5473068\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62246305"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":20189,"cells":{"query":{"kind":"string","value":"training linear classifier using stochastic gradient desent"},"document":{"kind":"string","value":"def train(self, X, y, learning_rate = 1e-3, reg = 1e-5, num_iter = 100, \r\n batch_size = 100, verbose = False):\r\n num_train, dim = X.shape\r\n num_classes = np.max(y) + 1 # assum y take values 0..K-1\r\n # initialize weight\r\n if self.W is None:\r\n self.W = 0.001 * np.random.randn(dim, num_classes)\r\n \r\n # SGD\r\n loss_history = []\r\n for iter in range(num_iter):\r\n batch_ix = np.random.choice(num_train, batch_size)\r\n X_batch = X[batch_ix]\r\n y_batch = y[batch_ix]\r\n \r\n loss, grad = self.loss(X_batch, y_batch, reg)\r\n loss_history.append(loss)\r\n self.W -= grad * learning_rate\r\n \r\n if verbose and iter % 100 == 0:\r\n print('iteration: %d / %d: loss: %f' %(iter, num_iter, loss))\r\n \r\n return loss_history"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in range(n):\r\n #sum over the instances to get an estimate of the gradient\r\n print((y[i] - self.learner.activate(features[i])))\r\n grad -= (y[i] - self.learner.activate(features[i])) * \\\r\n self.learner.grad(features[i])\r\n grad /= n\r\n #update paramter\r\n param = np.copy(self.learner.param)\r\n self.learner.param = param - self.alpha * grad\r\n #print(self.learner.param)\r","def fit(self, x, y):\n def initiate_theta(dim):\n self.theta = np.zeros(dim)\n # print('self.theta initiated is {}'.format(self.theta))\n \n def implement_sigmoid(x):\n if self.theta is None:\n initiate_theta(x.shape[1])\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\n \n def implement_partial_loss(x, y):\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\n \n def implement_transposed_hess(x):\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\n hess2 = np.diag(sigmoid_hadamard)\n hess = np.matmul(hess2,x)\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\n hess_inverse = np.linalg.inv(hess)\n return hess_inverse\n \n def train(x, y):\n count = 0\n if self.theta is None:\n initiate_theta(x.shape[1])\n while count < self.max_iter:\n if self.verbose:\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\n print('Average empirical loss for step {} is {}'.format(count, loss))\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\n new_theta = self.theta - delta * self.step_size\n delta_theta = np.linalg.norm(new_theta - self.theta)\n # print('delta is {}'.format(delta_theta))\n if delta_theta < self.eps:\n return new_theta\n else:\n self.theta = new_theta\n count += 1\n return self.theta\n \n return train(x, y)","def learn(self):\n Xt = np.append(np.ones((self.X.shape[0], 1)), self.X, axis=1)\n Yt = self.Y * 2 - 1\n\n w = np.ones(Xt.shape[1]) # avoiding random init, for debugging\n lw = [[] for k in range(len(w))]\n \n for iter in range(self.max_steps):\n P = Yt * np.dot(Xt, w)\n M = np.where(P <= 0)[0] # indices of misclassified datapoints\n\n if len(M) == 0: \n self.logger.debug(\"Found linearly separable hyperplane!\")\n break\n\n if self.is_stochastic:\n # just pick one randomly from M\n M = [M[random.randint(0, len(M)-1)]]\n\n grad = -1 * np.sum((Yt[M] * Xt[M].T), axis=1) / len(M)\n\n if self.reg_constant > 0:\n grad += self.reg_constant * w\n \n eta = self.step_size * 10000 / (10000 + iter)\n \n w = w - grad * eta\n \n if iter % 100 == 0:\n for k in range(len(w)):\n lw[k].append(w[k])\n \n if iter % 1000 == 0:\n self.logger.debug(\"Iter %s:\\t %f %f %f\" %(iter, w[0], w[1], w[2]))\n \n self.logger.debug(\"Iterations: %s\" %(iter))\n\n# x_range = range(len(lw[0]))\n# fig = plt.figure()\n# ax1 = fig.add_subplot(111) \n# for j, lwn in enumerate(lw):\n# if j % 3 >= 2: # plot an arbitrary subset of features\n# a = w[j]\n# ax1.plot(x_range, [(x-a) for x in lwn], label=str(j))\n# \n# plt.xlabel(\"Iteration\")\n# plt.ylabel(\"Feature weight\")\n# plt.show()\n \n #self.logger.debug(\"%s\" % np.array2string(w, precision=2, separator=','))\n \n self.w = w","def train(self, X, y):","def fit(x_train,x_test,y_train,y_test):\n #data=np.loadtxt(\"/home/manjunath/iris/iris.csv\", comments=None, delimiter=',', usecols=(0,1,2,3,4), converters={4: convert_y }) \n\n h=(10,10,10)\n step_size=0.001\n tolerence=0.001\n iteration_max=1000\n iteration=0\n #Regularisation param, added to gradients \n reg=0.01\n \n K=np.unique(y_train).shape[0]\n \n #x=np.loadtxt(\"/home/manjunath/iris/iris.csv\", comments=None, delimiter=',', converters=None, usecols=(0,1,2,3))\n \n \n \"\"\"\n \n train_mean=np.mean(x_train,axis=0)\n x_train=x_train-train_mean\n #std_x = np.sqrt(np.sum(np.square(x_train - train_mean),axis=0)/x_train.shape[1])\n std_x=np.std(x_train,axis=0)\n x_train=x_train/std_x\n \n x_test=x_test - train_mean\n x_test=x_test/std_x\n\n \"\"\"\n\n\n\n y_train=y_to_classification_form(y_train,K)\n y_test=y_to_classification_form(y_test,K)\n\n n_samples,n_features=x_train.shape\n gamma2=np.random.randn(h[0]).reshape(1,h[0])\n beta2=np.random.randn(h[0]).reshape(1,h[0])\n gamma3=np.random.randn(h[1]).reshape(1,h[1])\n beta3=np.random.randn(h[1]).reshape(1,h[1])\n eps=0.001\n \n w1=(np.random.randn(n_features*h[0]).reshape(n_features,h[0]))/np.sqrt(2/(n_features+h[0]))\n w2=(np.random.randn(h[0]*h[1]).reshape(h[0],h[1]))/np.sqrt(2/(h[0]+h[1]))\n w3=(np.random.randn(h[1]*h[2]).reshape(h[1],h[2]))/np.sqrt(2/(h[1]+h[2]))\n \n dw1_priv=np.zeros(w1.shape)\n dw2_priv=np.zeros(w2.shape)\n dw3_priv=np.zeros(w3.shape)\n \n #w3=(np.random.randn(h[1]*K).reshape(h[1],K)*0.5)/np.sqrt(2/h[1]+K)\n #Basically no significance, added bias for completion\n b1 = np.zeros((1,h[0]))\n b2 = np.zeros((1,h[1]))\n b3 = np.zeros((1,K))\n \n while iteration<iteration_max :\n \n #Calculate scores \n scores_layer1=np.dot(x_train,w1)+b1 # 125x4,4x10 = 125x10\n #print(\"iteration\",iteration, \"first layer\",np.any(np.isnan(scores_layer1)))\n #Do not use sigmoid, you will be stuck in long mess of nans and inf and overflows and div by zeros\n #x2=1/1+np.exp(-scores_layer1) # 150 x 4\n \n #Use reLU\n \n #x2=np.maximum(0,scores_layer1)\n bn_x2,bn_cache2=bn.batch_norm_forword(scores_layer1,gamma2,beta2) #125x10\n #print(\"iteration\",iteration, \"first layer BN\",np.any(np.isnan(bn_x2)))\n #x2=relu.relu_forword(bn_x2.T)\n x2=relu.relu_forword(bn_x2) #125x10\n #print(\"iteration\",iteration, \"first layer relu\",np.any(np.isnan(x2)))\n \n score_layer2=np.dot(x2,w2)+b2 #125x10,10x10=125x10\n #print(\"iteration\",iteration, \"second layer\",np.any(np.isnan(score_layer2)))\n bn_x3,bn_cache3=bn.batch_norm_forword(score_layer2,gamma3,beta3) #125x10\n x3=relu.relu_forword(bn_x3) #125x10 \n \n final_scores=np.dot(x3,w3)+b3 # 125x10,10x3=125x3\n \n #Again, use softmax or sigmoid loss for classification, MSE or distance is for regression only \n \n probs=fn.softmax(final_scores) #125x3\n \n \n \n dscores=fn.cross_enropy_grad_singleclass(probs,y_train) # 125x3\n #There is possibility of only 1 class for data, so use below, else the implementation will be bit complex \n #print(x3.shape)\n dw3=np.dot(x3.T,dscores) # 10x125,125x3=10x3\n dx3=np.dot(w3,dscores.T) # 10x3,3x125=10x125\n \n #dhid2=dx3.T\n #dhid2[x3<=0]=0\n \n dhid2=relu.relu_backword(dx3.T,x3) #125x10\n #print(\"dhid2\",dhid2.shape)\n bn_dhid2,dgamma3,dbeta3=bn.batch_norm_backword(dhid2,bn_cache3) #125x10\n #dprod = (x2 * (1- x2)) * dx2.T # this is wrong, find out why, we mostly need to multiply with upstream gradient \n \n dw2=np.dot(x2.T,bn_dhid2) # 10x125,125x10=10x10\n dx2=np.dot(w2,dhid2.T) #10x10,10x125=10x125\n \n #dhid1=dx2.T\n #dhid1[x2<=0]=0\n \n dhid1=relu.relu_backword(dx2.T,x2) #125x10\n \n bn_dx2,dgamma2,dbeta2=bn.batch_norm_backword(dhid1,bn_cache2) #125x10\n #print(dprod.shape)\n \n dw1 = np.dot( x_train.T,bn_dx2) # 125x4,12510=4x10\n\n db1=np.sum(b1,axis=0,keepdims=True) \n db2=np.sum(b2,axis=0,keepdims=True) \n db3=np.sum(b3,axis=0,keepdims=True)\n \n #Regularisation of gradients\n \n #Optimisation\n \n #dw1 = (dw1+dw1_priv)/2\n #dw2 = (dw2+dw2_priv)/2\n #dw3 = (dw3+dw3_priv)/2\n \n dw3 += reg*w3\n dw2 += reg*w2\n dw1 += reg*w1\n \n w1 = w1 - (step_size * dw1)\n w2 = w2 - (step_size * dw2)\n w3 = w3 - (step_size * dw3)\n \n #print(dw1)\n #print(dw2)\n #print(dw3)\n \n #dw1_priv=dw1\n #dw2_priv=dw2\n #dw3_priv=dw3\n \n \"\"\"\n redundant parameters after batch normalization \n \"\"\"\n \n b1 = b1 - (step_size * db1)\n b2 = b2 - (step_size * db2)\n b3 = b3 - (step_size * db3)\n \n\n \n gamma2= gamma2 - (step_size * dgamma2)\n beta2 = beta2 - (step_size * dbeta2)\n gamma3= gamma3 - (step_size * dgamma3)\n beta3 = beta3 - (step_size * dbeta3)\n\n \n if iteration%10 == 0 :\n #print(\"****iteration:\",iteration)\n #x_test /= 10 \n \n s1=np.dot(x_test,w1)\n #px2=1/1+np.exp(-s1)\n bn_x2t,bn_cache2t=bn.batch_norm_forword(s1,gamma2,beta2)\n px2=relu.relu_forword(bn_x2t)\n \n s2=np.dot(px2,w2) \n bn_x3t,bn_cache3t=bn.batch_norm_forword(s2,gamma3,beta3)\n px3=relu.relu_forword(bn_x3t)\n \n out=np.dot(px3,w3)\n \n counter=0\n for y_p,y_a in zip(np.argmax(out,axis=1),y_test):\n if np.argmax(y_a)==y_p:\n counter +=1\n print(\"accuracy: \", (counter/10000) *100,\"%\")\n loss=fn.cross_entropy_loss_singleclass(probs,y_train) # scalar\n print('Loss',loss/n_samples)\n \n dw1_p=np.zeros_like(dw1)\n dw2_p=np.zeros_like(dw2)\n dw3_p=np.zeros_like(dw3)\n \n print(\"dw1\",dw1==dw1_p)\n print(\"dw1\",dw2==dw2_p)\n print(\"dw1\",dw3==dw3_p)\n \n dw1_p=dw1\n dw2_p=dw2\n dw3_p=dw3\n \n #print(\"gamma2\",gamma2)\n #print(\"beta2\",beta2)\n \n iteration=iteration+1\n \n #print('FInal weights are: ', w1,w2)","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\n \n for j in range(self.feature_count): # Loop over each feature\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \n numerator = single_word_count + self.alpha\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\n \n start_index = end_index","def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\r\n # Step 0: Initialize the parameters\r\n n_samples, n_features = X.shape\r\n self.weights = np.zeros(shape=(n_features,1))\r\n self.bias = 0\r\n costs = []\r\n\r\n for i in range(n_iters):\r\n # Step 1: Compute a linear combination of the input features and weights\r\n y_predict = np.dot(X, self.weights) + self.bias\r\n\r\n # Step 2: Compute cost over training set\r\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\r\n costs.append(cost)\r\n\r\n if i % 100 == 0:\r\n print(f\"Cost at iteration {i}: {cost}\")\r\n\r\n # Step 3: Compute the gradients\r\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\r\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \r\n \r\n # Step 4: Update the parameters\r\n self.weights = self.weights - learning_rate * dJ_dw\r\n self.bias = self.bias - learning_rate * dJ_db\r\n\r\n return self.weights, self.bias, costs","def ff_train(\n self, input_tensor: torch.Tensor, labels: torch.Tensor, theta: float\n ):\n with torch.no_grad():\n states, neg_samples = self.bottom_up(input_tensor, labels)\n neg_states, _ = self.bottom_up(input_tensor, neg_samples)\n states = [\n torch.cat([s, ns], dim=0) for s, ns in zip(states, neg_states)\n ]\n signs = torch.cat(\n [\n torch.ones(input_tensor.shape[0], device=self.device),\n -torch.ones(input_tensor.shape[0], device=self.device),\n ],\n dim=0,\n )\n input_tensor = torch.cat([input_tensor, input_tensor], dim=0)\n # states have been created, now we can train the network\n x_proj, accumulated_goodness = self.projector.ff_train(\n input_tensor, signs, theta\n )\n for _ in range(self.time_steps):\n new_states = []\n x = x_proj\n for j, layer in enumerate(self.layers):\n if j < len(self.layers) - 1:\n next_state = states[j + 2]\n else:\n next_state = self.proj_y(states[j + 2].float())\n new_states.append(x)\n x, goodnesses = layer.ff_train(\n states[j], states[j + 1], next_state, signs, theta\n )\n accumulated_goodness[0] += goodnesses[0]\n accumulated_goodness[1] += goodnesses[1]\n new_states.append(x)\n with torch.no_grad():\n x_ = states[-2][torch.where(signs == -1)]\n real_y = states[-1][torch.where(signs == 1)]\n x_[\n torch.arange(x_.shape[0]), torch.argmax(real_y, dim=1)\n ] = -1e6\n y = self.softmax(x_)\n cumulative_y = torch.cumsum(y, dim=1)\n neg_samples = torch.argmax(\n 1.0\n * (\n cumulative_y\n > torch.rand(x_.shape[0], 1).to(self.device)\n ),\n dim=1,\n )\n neg_samples = torch.functional.F.one_hot(\n neg_samples, num_classes=self.num_labels\n )\n # replace just negative samples\n next_labels = states[-1].clone()\n next_labels[torch.where(signs == -1)] = neg_samples\n new_states.append(next_labels)\n states = new_states\n accumulated_goodness[0] /= self.time_steps * len(self.layers) + 1\n accumulated_goodness[1] /= self.time_steps * len(self.layers) + 1\n with torch.no_grad():\n states = [t[: input_tensor.shape[0] // 2] for t in states]\n return states, accumulated_goodness","def trainNN():\n\n yTrain = [] # holds y vals of curves/lines\n trainLabels = [] # holds center labels\n\n tryCenters = np.linspace(1, 9, 45)\n\n for i in range(len(tryCenters)):\n x = np.linspace(tryCenters[i]-.2, tryCenters[i]+.2, 18)\n for j in range(1000):\n centers = round(random.uniform(tryCenters[i]-.05,\n tryCenters[i]+.05), 1)\n y = gauss_func(x, .05, centers, 1)\n yTrain.append(y)\n trainLabels.append(1)\n\n y = gauss_func(x, .05,\n round(random.uniform(tryCenters[i]-.3,\n tryCenters[i]-.17), 1), 1)\n yTrain.append(y)\n trainLabels.append(0)\n\n y = gauss_func(x, .05,\n round(random.uniform(tryCenters[i]+.17,\n tryCenters[i]+.3), 1), 1)\n yTrain.append(y)\n trainLabels.append(0)\n\n y = 0*x\n yTrain.append(y)\n trainLabels.append(0)\n clf = MLPClassifier(solver='lbfgs')\n clf.fit(yTrain, trainLabels)\n return clf","def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n if self.W is None:\n self.W = np.random.randn(dim, num_classes) * 0.001\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n for it in xrange(num_iters):\n batch_ind = np.random.choice(X.shape[0],batch_size, replace=True)\n X_batch = X[batch_ind]\n y_batch = y[batch_ind]\n\n # Step One: Implement Stochastic\n #########################################################################\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n\n # Step Two: Implement Gradient\n # Simply call self.loss (which calls svm_loss_vectorized) to evaluate loss and gradient\n loss, dW = self.loss(X_batch,y_batch,reg)\n loss_history.append(loss)\n\n # Step Three: Implement Descent\n # Simply update the weights using the gradient and the learning rate. #\n self.W -= dW*learning_rate\n\n if verbose and it % 100 == 0:\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def train(self, X, y):\n m = X.shape[0]\n D = np.empty(m)\n D.fill(1/(m*1.0))\n\n hs = 0\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n eps = 0\n\n for j in range(m): \n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\n eps+=D[j]\n\n self.w[t] =0.5*math.log((1/eps)-1)\n\n Dtmp = []\n for j in range(m):\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\n\n Dtmp = np.array(Dtmp) \n s = np.sum(Dtmp)\n\n for i in range(m):\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s","def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\n\n # Initialize the bias and weights.\n m, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n n_sample = int(m * sample_rate)\n for i in range(epochs):\n for idx in choice(range(m), n_sample, replace=False):\n # Calculate the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\n\n # Update the bias and weight by gradient of current sample\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights\n\n # Show the gradient of each epoch.\n grad_bias, grad_weights = self._get_gradient(X, y)\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)","def train(self, dataset): \n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\n #print dataset\n \n ########\n # Compute p(y=1) for all ys.\n ########\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \n \n ########\n # Compute p(x|y) for all x,y.\n ########\n self.feature_count = len(dataset[0]) - 1 \n self.class_count = len(label_counts)\n \n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\n start_index = 0\n for i in range(self.class_count): # Loop over each class \n end_index = start_index + label_counts[i] # end of this class index \n denominator = label_counts[i] + 2.0 * self.alpha\n \n for j in range(self.feature_count): # Loop over each feature\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\n \n start_index = end_index","def fit(self, X, y, alpha, n_epochs):\n y = self.__one_hot(y)\n \n # perform training epochs\n for i in range(n_epochs):\n print(\"Epoch\", i)\n # stochastic gradient descent\n for j in range(len(X)):\n self.__backpropagation(X[j], y[j], alpha)","def train_SGD():\n\n #load the data\n path_dataset = \"data/data_train.csv\"\n train = load_data(path_dataset)\n\n \"\"\"matrix factorization by SGD.\"\"\"\n\n #define parameters (optimal parameters from cross-validation)\n gamma = 0.12\n num_features = 25 \n lambda_user = 0.02 \n lambda_item = 0.24\n num_epochs = 100\n\n #run the factorization\n user_features, item_features = matrix_factorization_SGD(train, num_features, lambda_user, lambda_item, num_epochs, gamma)\n\n #save item_features_SGD\n file = open(\"data/item_features_SGD.obj\",\"wb\")\n pickle.dump(item_features,file)\n file.close()\n\n #save user_features_SGD\n file = open(\"data/user_features_SGD.obj\",\"wb\")\n pickle.dump(user_features,file)\n file.close()","def train(net):\n\n # Set SGD hyperparameters\n n_iter = 200 # number of iterations of SGD\n learning_rate = 1e-3 # learning rate for SGD\n momentum = .99 # momentum parameter for SGD\n batch_size = 100 # number of data points in each mini-batch\n\n # Initialize binary cross-entropy loss function\n loss_fn = nn.BCELoss()\n\n # Initialize SGD optimizer with momentum\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)\n\n # Placeholder to save loss at each iteration\n track_loss = []\n\n # Loop over iterations\n for i in range(n_iter):\n\n # Sample minibatch of oriented grating stimuli\n stimuli, tilt = sample_stimuli(batch_size)\n\n # Evaluate loss and update network weights\n out = net(stimuli) # predicted probability of tilt right\n loss = loss_fn(out, tilt) # evaluate loss\n optimizer.zero_grad() # clear gradients\n loss.backward() # compute gradients\n optimizer.step() # update weights\n \n # Keep track of loss at each iteration\n track_loss.append(loss.item())\n\n # Track progress\n if (i + 1) % (n_iter / 10) == 0:\n print('iteration %i | loss: %.3f | percent correct: %.2f%%' % (i + 1, loss.item(), 100 * pcorrect(out, tilt)))\n \n # Plot loss\n plt.plot(track_loss)\n plt.xlabel('iterations of SGD')\n plt.ylabel('binary cross-entropy loss')\n plt.xlim([0, None])\n plt.ylim([0, None])\n plt.show()","def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\"Delta\"):\n rem = int(np.ceil(len(X[0])/batch_size))\n for epoch in range(num_epochs):\n art = 0;\n for sample in range(rem):\n end = art + batch_size\n\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\n sampleX = X[:, art : end]\n sampleY = y[:, art : end]\n #print (sampleX)\n\n # Get the prediction\n results = self.predict(sampleX)\n art += batch_size\n\n if learning == \"Delta\" or learning == \"delta\":\n # Calculate e\n e = np.subtract(sampleY, results)\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(e, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)\n \n elif learning == \"Filtered\" or learning == \"filtered\":\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(sampleY, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Multiply the old weights by some scalar gamma\n gw = np.multiply(1 - gamma, self.weights)\n\n self.weights = np.add(gw, aep)\n\n elif learning == \"Unsupervised_hebb\" or learning == \"unsupervised_hebb\":\n # Add a row of one's to the top of the input matrix\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(results, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)","def train(self, X, y, learning_rate=1e-3, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n\n self.init_weights(dims=[np.max(y) + 1, X.shape[1]])\t# initializes the weights of self.W\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n\n for it in np.arange(num_iters):\n X_batch = None\n y_batch = None\n\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in \n # gradient descent. After sampling,\n # - X_batch should have shape: (dim, batch_size)\n # - y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations\n # in the dataset. Use np.random.choice. It's okay to sample with\n # replacement.\n # ================================================================ #\n mask = np.random.choice(num_train, batch_size, replace=True)\n \n X_batch = X[mask] # (dim, batch_size)\n y_batch = y[mask] # (batch_size,)\n \n pass\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n # evaluate loss and gradient\n loss, grad = self.fast_loss_and_grad(X_batch, y_batch)\n loss_history.append(loss)\n\n # ================================================================ #\n # YOUR CODE HERE:\n # Update the parameters, self.W, with a gradient step \n # ================================================================ #\n pass\n \n self.W = self.W - learning_rate*grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n if verbose and it % 100 == 0:\n print('iteration {} / {}: loss {}'.format(it, num_iters, loss))\n\n return loss_history","def trainModel( self, featureTrain, classTrain):","def train(features, targets, weights, bias):\n # see gradient_descent for explanation\n epochs = 100\n learning_rate = 0.1\n\n picture_nb = 2\n\n # Print current accuracy. How many people have been classified as sick/healthy correctly?\n predictions = predict(features, weights, bias)\n print(\"Accuracy: \", np.mean(predictions == targets))\n\n for epoch in range(epochs):\n if epoch % 10 == 0:\n # get normalized scores\n predictions = activation(pre_activation(features, weights, bias))\n # compare with targets to see how bad our algorithm is\n print(\"Cost = %s\" % cost(predictions, targets))\n # Replot graph. Check in create_dataset for explanation of parameters\n if picture_nb == 2:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='red')\n elif picture_nb == 11:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='green')\n else:\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='orange')\n picture_nb+=1\n\n # Initialize gradients\n # weights_gradients is 2D array with 2 values\n weights_gradients = np.zeros(weights.shape)\n bias_gradient = 0\n # Go through each row\n for feature, target in zip(features, targets):\n # Compute prediction\n z = pre_activation(feature, weights, bias)\n # Get normalized score\n y = activation(z)\n # Update gradients based on formulas established before. Look at gradient_descent to understand what we\n # are doing. Also, the formulas are below, just before the call of the function train.\n weights_gradients += (y - target) * derivative_activation(z) * feature\n # no multiplication of feature because it does not depend on some coordinates.\n bias_gradient += (y - target) * derivative_activation(z)\n\n # Update variables. These are the lines that result the cost to get reduced.\n weights = weights - learning_rate * weights_gradients\n bias = bias - learning_rate * bias_gradient\n\n # Print final accuracy. How many people have been classified as sick/healthy correctly?\n predictions = predict(features, weights, bias)\n print(\"Accuracy: \", np.mean(predictions == targets))\n\n plt.scatter(features[:, 0], features[:, 1], s=40, c=targets, cmap=plt.cm.Spectral)\n plt.savefig(\"DataPointsLineEvolution.png\")\n # legend for understanding\n plt.legend(['Original division', 'New division', 'New division', 'New division', 'New division', 'New division',\n 'New division', 'New division', 'New division', 'Final division'], loc='upper left')\n # save picture of data points drawn.\n plt.savefig(\"DataPointsLineEvolutionLegend.png\")","def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\n num_feats = X.shape[1]\n num_samples = X.shape[0]\n\n y = y.reshape(num_samples, 1)\n W = np.random.rand(num_feats, 1)\n training_loss_epochs = []\n\n for ix in range(epochs):\n shuffled_ix = (np.arange(0, len(X)))\n np.random.shuffle(shuffled_ix)\n X = X[shuffled_ix, :]\n y = y[shuffled_ix, :]\n\n for batch_ix in np.arange(0, X.shape[0], batch_size):\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\n W -= learning_rate * dW\n\n if ix % 10 == 0:\n y_pred = np.dot(X, W)\n training_loss = self.mse(y, y_pred)\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\n training_loss_epochs.append(training_loss[0])\n\n self.weights = W\n self.training_loss = training_loss_epochs\n return None","def ff_train(\n self, input_tensor: torch.Tensor, signs: torch.Tensor, theta: float\n ):\n # upgrade optimizer for positive goodness\n y = self(input_tensor.detach())\n y_pos = y[torch.where(signs == 1)]\n y_neg = y[torch.where(signs == -1)]\n # y_pos = self(input_tensor.detach()[torch.where(signs == 1)])\n loss_pos, cumulated_logits_pos = self.loss_fn(y_pos, theta, sign=1)\n # self.optimizer.zero_grad()\n # loss_pos.backward()\n # print(loss_pos.item())\n # self.optimizer.step()\n # y_neg = self(input_tensor.detach()[torch.where(signs == -1)])\n loss_neg, cumulated_logits_neg = self.loss_fn(y_neg, theta, sign=-1)\n self.optimizer.zero_grad()\n loss = loss_pos + loss_neg\n loss.backward()\n self.optimizer.step()\n separation = [cumulated_logits_pos, cumulated_logits_neg]\n y = torch.zeros(\n input_tensor.shape[0], *y_pos.shape[1:], device=input_tensor.device\n )\n y[torch.where(signs == 1)] = y_pos\n y[torch.where(signs == -1)] = y_neg\n return y.detach(), separation","def train(self, F, Y_batch):\n H_init = np.array(Y_batch.numpy(), copy=True)\n H_init[H_init.sum(1) > 1] *= 0\n H,Z= solve_H(torch.FloatTensor(H_init), F,self.dist,Y=Y_batch.numpy(),iters=self.solve_H_iters, return_Z=True)\n Z_aug = Variable(Z[None].repeat(F.size()[0], 1,1))\n tv_F = Variable(F, requires_grad=True)\n F_aug = tv_F[:,None].repeat(1,Z.size()[0],1)\n d = torch.pow(Z_aug- F_aug,2).sum(-1)[...,0] # (N, K) distances to clusters\n ##\n tv_Y = Variable(torch.LongTensor(H.numpy().argmax(1)))\n py_x = self.lsoftmax(-d)\n loss = self.nll(py_x, tv_Y)\n ##\n loss.backward()\n G = tv_F.grad.data \n train_pred = H.numpy().argmax(1)\n return loss.data[0], G, train_pred","def trainSVM(dataSet, epochs, C, rho):\n \n D = len(dataSet[0][0]);\n w = np.zeros(D);\n t = 0;\n \n # run for some epochs, over every training point in random order on each epoch \n for epoch in range(epochs): \n\n random.shuffle(dataSet); \n for [x, y] in dataSet:\n \n # compute learning rate for this itr\n r = rho/(1 + rho*t/C); \n \n # compute gradient on single example\n if y*np.dot(w, x) <= 1:\n grad = w - C*y*x;\n else:\n grad = w;\n \n # update weight vector\n w = w - r*grad;\n \n t = t + 1;\n \n return w;","def train(self, loss_function='logistic',\n lr=0.1, decay=0.5, max_iters=3000, batch_size=128, **kwargs):\n return super(LogisticRegression, self).train('sgd', loss_function,\n lr=lr,\n decay=decay, max_iters=max_iters,\n batch_size=batch_size, **kwargs)","def gradient_descent(self, x, y):\n # Initialize weights vector\n self.weights = np.zeros(len(x[0]))\n\n # Storing number of training example in a variable \n n = len(x)\n\n # Initiate variables to keep track of the current and smallest loss recorded\n lowest_loss = sys.float_info.max\n current_loss = sys.float_info.max\n\n # Initiate variables to keep track of step sizes\n norm = sys.float_info.max\n smallest_norm = sys.float_info.max\n\n # Initiate list variable that stores all previous weights\n prev_weights = []\n\n # Initiate list that stores all the errors. \n errors = []\n \n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\n k_loss_iteration = 1\n\n # Learning loop\n for i in range(self.max_iter):\n\n # Append current weights\n prev_weights.append(np.array(self.weights))\n \n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\n\n # Compute the error of the Cost Function and store it in a list\n current_loss = self.cost(x,y)\n\n if len(errors) > 1 and current_loss > errors[-1]:\n k_loss_iteration += 1\n else: \n k_loss_iteration = 1\n\n errors.append(current_loss)\n \n # Track smallest loss\n if current_loss < lowest_loss:\n lowest_loss = current_loss\n\n # Compute the L2 Norm of the difference between current weights and previous weights\n norm = np.linalg.norm(self.weights - prev_weights[-1])\n\n # Track smallest step size and set it as error threshold\n if norm < smallest_norm:\n smallest_norm = norm\n\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\n if self.error_threshold != None and norm < self.error_threshold:\n print(\"Converged after {} iterations!\".format(i))\n break\n\n # stop if error hasn't gone down in k iterations\n if k_loss_iteration >= 10:\n print(k_loss_iteration + \" iterations of loss not decreasing on {}th itertion.\".format(i))\n break\n\n # Log final weights\n print(\"Final norm: \" + str(norm) + \"\\nSmallest step size recorded: \" + str(smallest_norm) + \"\\nFinal error: \" + str(current_loss) + \"\\nLowest error recorded: \" + str(lowest_loss) + \"\\nNumber of epochs: \" + str(len(errors)) + \"\\nFinal weights: \" + str(self.weights))","def train_model(X_train, y_train):\n rgs = linear_model.Lasso(alpha=0.1)\n rgs.fit(X_train, y_train)\n return rgs","def train( self, trainingData, trainingLabels, validationData, validationLabels ):\n\n self.features = trainingData[0].keys() # could be useful later\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\n for iteration in range(self.max_iterations):\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n print (\"Starting iteration \", iteration, \"...\")\n for i in range(len(trainingData)):#training data\n max = -10000000\n for j in range(len(self.weights)):\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\n if (prod > max):\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\n indclase=j #guardas el índice de la clase a la que predices que pertenece\n\n if(indclase != trainingLabels[i]):\n # recalcular pesos\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\n\n\n\n\n\n ########################################################################################\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\n # Asi cada ejemplo es de dimension 1 filas y self.features).\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\n #########################################################################################","def train_classifier(train_data, dev_data, num_iterations, learning_rate, params):\n\n for I in xrange(num_iterations):\n cum_loss = 0.0 # total loss in this iteration.\n random.shuffle(train_data)\n for label, features in train_data:\n x = feats_to_vec(features) # convert features to a vector.\n y = utils.L2I[label] # convert the label to number if needed.\n loss, grads = ll.loss_and_gradients(x,y,params)\n cum_loss += loss\n # YOUR CODE HERE\n # update the parameters according to the gradients\n # and the learning rate.\n params[0] -= learning_rate * grads[0]\n params[1] -= learning_rate * grads[1]\n train_loss = cum_loss / len(train_data)\n train_accuracy = accuracy_on_dataset(train_data, params)\n dev_accuracy = accuracy_on_dataset(dev_data, params)\n print I, train_loss, train_accuracy, dev_accuracy\n return params","def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\n loss_history = []\n N,d = X.shape\n for t in np.arange(num_iters):\n X_batch = None\n y_batch = None\n # ================================================================ #\n # YOUR CODE HERE:\n # Sample batch_size elements from the training data for use in gradient descent. \n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\n # The indices should be randomly generated to reduce correlations in the dataset. \n # Use np.random.choice. It is better to user WITHOUT replacement.\n # ================================================================ #\n \n # sample indices without replacement\n batch_idx = np.random.choice(N, batch_size, replace = False)\n X_batch = X[batch_idx]\n y_batch = y[batch_idx]\n \n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss = 0.0\n grad = np.zeros_like(self.w)\n # ================================================================ #\n # YOUR CODE HERE: \n # evaluate loss and gradient for batch data\n # save loss as loss and gradient as grad\n # update the weights self.w\n # ================================================================ #\n \n # compute the loss and gradient\n # loss_and_grad will take responsible for these\n \n loss, grad = self.loss_and_grad(X_batch, y_batch)\n \n self.w = self.w - eta * grad\n \n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n loss_history.append(loss)\n return loss_history, self.w","def learn(self, Xtrain, ytrain):","def nnRegression(data):","def fit(self, X, Y, lrate=0.01, training_steps=100, coeff_reg=0.1):#, batch_size=1):\n num_instances = len(X)\n num_features = len(X[0])\n\n x = T.matrix(\"x\")\n y = T.vector(\"y\")\n w = theano.shared(np.random.random((num_features,)), name=\"w\")\n b = theano.shared(0., name=\"b\")\n\n #p = 1 / (1 + T.exp(-(T.dot(x, w) + b)))\n p = (1 + T.tanh(-(T.dot(x, w) + b))) / 2\n cost = ((p - y) ** 2).sum() + coeff_reg * (w ** 2).sum()\n gw, gb = T.grad(cost, [w, b])\n\n train = theano.function(\n inputs=[x,y],\n outputs=[cost],\n updates=((w, w - lrate * gw), (b, b - lrate * gb)),\n allow_input_downcast=True)\n\n cst = [0] * training_steps\n #num_batches = num_instances // batch_size\n for i in xrange(training_steps):\n \"\"\"\n for j in xrange(num_batches):\n #lidx = j*batch_size\n #uidx = min(num_instances, lidx+batch_size)\n #err = train(X[lidx:uidx], Y[lidx:uidx])\n err = train(X[j:(j+1)], Y[j:(j+1)])\n \"\"\"\n err = train(X, Y)\n cst[i] = sum(err)\n print \"%d\\t%f\" % (i, cst[i])\n\n plt.plot(cst)\n #plt.show()\n plt.savefig('bgd.png')\n\n self.w = w.get_value()\n self.b = b.get_value()","def fit(self, X, Y):\n X = X.toarray() # convert X to ndarray\n Y = Y.to_numpy() # convert Y to numpy array\n Y[Y == 0] = -1 # convert all zeros to -1, the SVM works with -1 and 1 values\n\n self.w = np.zeros(X.shape[1])\n self.b = 0\n\n for iter in range(self.iterations):\n X, Y = shuffle(X, Y)\n for idx, x_i in enumerate(X):\n dw, db = self.compute_gradients(x_i, Y[idx])\n self.update_gradients(dw, db)","def train(train_ds):\n rng = random.PRNGKey(0)\n\n # initialise the model\n py, params = GPModel.init(rng, train_ds['index_points'])\n model = nn.Model(GPModel, params)\n\n # utility functions for packing and unpacking param dicts\n par_from_array, array_from_par = build_par_pack_and_unpack(model)\n\n @jax.jit\n def loss_fun(model: GPModel, params: dict) -> float:\n \"\"\" This is clumsier than the usual FLAX loss_fn. \"\"\"\n py = model.module.call(params, train_ds['index_points'])\n return -py.log_prob(train_ds['y'])\n\n # wrap loss fun for scipy.optimize\n def wrapped_loss_fun(arr):\n params = par_from_array(arr)\n return loss_fun(model, params)\n\n @jax.jit\n def loss_and_grads(x):\n return jax.value_and_grad(wrapped_loss_fun)(x)\n\n res = oscipy.optimize.minimize(\n loss_and_grads,\n x0=array_from_par(params),\n jac=True,\n method='BFGS')\n\n logging.info('Optimisation message: {}'.format(res.message))\n\n trained_model = model.replace(params=par_from_array(res.x))\n return trained_model","def train_step(self, batch):\n user, pos, neg = batch\n with tf.GradientTape() as t:\n\n # Clean Inference\n xu_pos, gamma_u, gamma_pos, emb_pos_feature, theta_u, beta_pos = \\\n self(inputs=(user, pos), training=True)\n xu_neg, _, gamma_neg, _, _, beta_neg = self(inputs=(user, neg), training=True)\n\n result = tf.clip_by_value(xu_pos - xu_neg, -80.0, 1e8)\n loss = tf.reduce_sum(tf.nn.softplus(-result))\n\n # Regularization Component\n reg_loss = self.reg * tf.reduce_sum([tf.nn.l2_loss(gamma_u),\n tf.nn.l2_loss(gamma_pos),\n tf.nn.l2_loss(gamma_neg),\n tf.nn.l2_loss(theta_u)]) * 2 \\\n + self.reg * tf.nn.l2_loss(beta_pos) * 2 \\\n + self.reg * tf.nn.l2_loss(beta_neg) * 2 / 10 \\\n + self.reg * tf.reduce_sum([tf.nn.l2_loss(self.E), tf.nn.l2_loss(self.Bp)]) * 2\n\n # Loss to be optimized\n loss += reg_loss\n\n params = [\n self.Bi,\n self.Gu,\n self.Gi,\n self.Tu,\n self.E,\n self.Bp\n ]\n\n grads = t.gradient(loss, params)\n self.optimizer.apply_gradients(zip(grads, params))\n\n return loss.numpy()","def train(self, X, Y, init='zeros', stepsize=.01, tolerance=1e-4, max_steps=5000):\n\t\tif self.wts[0].shape[1] - 1 != len(X[0]):\n\t\t\traise ValueError('NNetClassify.__init__: sizes[0] must == len(X) (number of features)')\n\n\t\tif len(np.unique(Y)) != self.wts[-1].shape[0]:\n\t\t\traise ValueError('NNetClassify.__init__: sizes[-1] must == the number of classes in Y')\n\n\t\tself.classes = self.classes if self.classes else np.unique(Y)\n\n\t\t# convert Y to 1-of-K format\n\t\tY_tr_k = to_1_of_k(Y)\n\n\t\tn,d = mat(X).shape\t\t\t\t\t\t\t\t\t\t\t\t\t# d = dim of data, n = number of data points\n\t\tnc = len(self.classes)\t\t\t\t\t\t\t\t\t\t\t\t# number of classes\n\t\tL = len(self.wts) \t\t\t\t\t\t\t\t\t\t\t\t\t# get number of layers\n\n\t\t# define desired activation function and it's derivative (for training)\n\t\tsig,d_sig, = self.sig, self.d_sig\n\t\tsig_0,d_sig_0 = self.sig_0, self.d_sig_0\n\n\t\t# outer loop of stochastic gradient descent\n\t\titer = 1\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# iteration number\n\t\tdone = 0\t\t\t\t\t\t\t\t\t\t\t\t\t\t\t# end of loop flag\n\n\t\tsurr = np.zeros((1, max_steps + 1)).ravel()\t\t\t\t\t\t\t# surrogate loss values\n\t\terr = np.zeros((1, max_steps + 1)).ravel()\t\t\t\t\t\t\t# misclassification rate values\n\n\t\twhile not done:\n\t\t\tstep_i = stepsize / iter\t\t\t\t\t\t\t\t\t\t# step size evolution; classic 1/t decrease\n\t\t\t\n\t\t\t# stochastic gradient update (one pass)\n\t\t\tfor i in range(n):\n\t\t\t\tA,Z = self.__responses(self.wts, X[i,:], sig, sig_0)\t\t# compute all layers' responses, then backdrop\n\t\t\t\tdelta = (Z[L] - Y_tr_k[i,:]) * arr(d_sig_0(Z[L]))\t\t\t# take derivative of output layer\n\n\t\t\t\tfor l in range(L - 1, -1, -1):\n\t\t\t\t\tgrad = mat(delta).T * mat(Z[l])\t\t\t\t\t\t\t# compute gradient on current layer wts\n\t\t\t\t\tdelta = np.multiply(delta.dot(self.wts[l]), d_sig(Z[l]))# propagate gradient downards\n\t\t\t\t\tdelta = delta[:,1:]\t\t\t\t\t\t\t\t\t\t# discard constant feature\n\t\t\t\t\tself.wts[l] = self.wts[l] - step_i * grad\t\t\t\t# take gradient step on current layer wts\n\n\t\t\terr[iter] = self.err_k(X, Y_tr_k)\t\t\t\t\t\t\t\t# error rate (classification)\n\t\t\tsurr[iter] = self.mse_k(X, Y_tr_k)\t\t\t\t\t\t\t\t# surrogate (mse on output)\n\n\t\t\tprint('surr[iter]')\n\t\t\tprint(surr[iter])\n\t\t\tprint('iter')\n\t\t\tprint(iter)\n\n\t\t\t# check if finished\n\t\t\tdone = (iter > 1) and (np.abs(surr[iter] - surr[iter - 1]) < tolerance) or iter >= max_steps\n\t\t\titer += 1","def train(self, target):\n\n n_it = 0\n\n # print(\"\\nsomme_erreure maximale (calcul initial) = \" + str(somme_erreur_av)+'\\n')\n\n while self.training:\n\n L_erreures_normalisees_base_training = []\n L_erreures_normalisees_base_test = []\n\n # on entraine le reseau en passant 100 fois la base d'exemple\n for k in range(100):\n\n # calcul de l'erreur cummulée sur toute la base d'exemple\n somme_erreur = [0, 0] # pour le gradient\n somme_erreur_carré = [0, 0]\n somme_erreur_carré_test = [0, 0]\n\n for i in range(len(sample_position)):\n command = self.network.runNN(\n sample_position[i]) # propage erreur et calcule la vitesse des roues instant t\n erreur = [(command[0] - sample_command[i][0]), (command[1] - sample_command[i][1])]\n somme_erreur[0] += erreur[0]\n somme_erreur[1] += erreur[1]\n\n somme_erreur_carré[0] += erreur[0] ** 2\n somme_erreur_carré[1] += erreur[1] ** 2\n\n # self.network.backPropagate(erreur, 0.0001, 0) ne marche pas bien\n\n # ajout de l'erreure au carré normaliséé par la taille de la base d'apprentissage et moyenné sur les 2 roues\n L_erreures_normalisees_base_training.append((somme_erreur_carré[0] / (1 * len(sample_position)) +\n somme_erreur_carré[1] / (1 * len(sample_position))) / 2)\n\n # print(\"A l'itération \" + str(n_it) + \", somme_erreur_carré = \"+str(somme_erreur_carré))\n\n grad = [0, 0]\n grad[0] = somme_erreur[0] / (1 * len(sample_position)) # erreur moyenne\n grad[1] = somme_erreur[1] / (1 * len(sample_position))\n\n self.network.backPropagate(grad, 0.005, 0)\n # grad, pas d'app, moment : permet de lisser la trajectoire\n\n n_it += 1\n\n # Fin de l'itération pour la base d'apprentissage, début pour la base de test\n for i in range(len(test_position)):\n command = self.network.runNN(\n test_position[i]) # propage erreur et calcule la vitesse des roues instant t\n erreur_test = [(command[0] - test_command[i][0]), (command[1] - test_command[i][1])]\n somme_erreur_carré_test[0] += erreur_test[0] ** 2\n somme_erreur_carré_test[1] += erreur_test[1] ** 2\n\n L_erreures_normalisees_base_test.append((somme_erreur_carré_test[0] / (1 * len(test_position)) +\n somme_erreur_carré_test[1] / (1 * len(test_position))) / 2)\n\n # Tracé des courbes\n pl.clf()\n X = [i + 1 for i in range(len(L_erreures_normalisees_base_training))]\n # X2 = [i + 1 for i in range(len(L_erreures_normalisees_base_training))]\n\n pl.plot(X, L_erreures_normalisees_base_training, 'r+')\n pl.plot(X, L_erreures_normalisees_base_test, 'bo')\n\n # base d'entrainement affichée avec des croix rouges\n # base de test affichée avec des ronds bleu\n\n pl.show()\n\n self.training = False\n\n # print(\"\\nsomme_erreur finale = [\" + str(somme_erreur[0]) + \",\" + str(somme_erreur[1]) + \"]\")\n print(\"\\nTraining done after \" + str(n_it) + \" iterations !\")\n\n # version avec arret quand l'erreure augmente\n # if (somme_erreur[0]+somme_erreur[1]) < (somme_erreur_av[0]+somme_erreur_av[1]) :\n # self.network.backPropagate(grad, 0.9,0) # grad, pas d'app, moment : permet de lisser la trajectoire\n # somme_erreur_av = somme_erreur\n # n_it+=1\n ##print(\"n_it = \"+ str(n_it)+\"\\n\")\n\n # else :\n # self.training = False\n # print(\"Training done after \" + str(n_it) +\" iterations !\")\n\n while self.running:\n position = self.robot.get_position()\n\n network_input = [0, 0, 0]\n\n # calcul de la position relative de la cible dans le referentiel du robot\n network_input[0] = ((target[0] - position[0]) * math.cos(position[2]) + (\n target[1] - position[1]) * math.sin(position[2])) * self.alpha[0]\n network_input[1] = ((target[0] - position[0]) * (-1) * math.sin(position[2]) + (\n target[1] - position[1]) * math.cos(position[2])) * self.alpha[1]\n network_input[2] = (-1) * (position[2] - target[2]) * self.alpha[2]\n\n command = self.network.runNN(network_input) # propage erreur et calcul vitesses roues instant t\n print(\"command =\" + str(command))\n\n # dénormaliser la commande\n command = M * command\n\n self.robot.set_motor_velocity(command) # applique vitesses roues instant t,\n time.sleep(0.050) # attend delta t\n\n self.robot.set_motor_velocity([0, 0]) # stop apres arret du prog d'app\n # position = self.robot.get_position() # obtient nvlle pos robot instant t+1\n # Teta_t=position[2]\n\n self.running = False","def train(self, F, Y_batch):\n H_init = np.array(Y_batch.numpy(), copy=True)\n H_init[H_init.sum(1) > 1] *= 0\n H_init = Variable(torch.FloatTensor(H_init))\n F = Variable(F, requires_grad=True)\n Z = torch.mm(inv_H(H_init), F)\n # 1st iteration\n Z_aug = Z[None].repeat(F.size()[0], 1,1)\n F_aug = F[:,None].repeat(1,Z.size()[0],1)\n d = torch.pow(Z_aug- F_aug,2).sum(-1)[...,0] # (N, K) distances to clusters\n\n ##\n mask = np.zeros(Y_batch.numpy().shape)\n mask[H_init.data.numpy().sum(1) == 1] = 1\n mask = torch.FloatTensor(mask)\n\n tv_Y = Variable(torch.LongTensor((-1*mask*Y_batch + (1-mask)*d.data).numpy().argmin(1) ))\n py_x = self.lsoftmax(-d)\n loss = self.nll(py_x, tv_Y)\n ##\n loss.backward()\n G = F.grad.data \n train_pred = d.data.numpy().argmin(1)\n return loss.data[0], G, train_pred","def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\n if len(y.shape) == 1:\n y = y.reshape((-1, 1))\n if not (0 < lr < 1):\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\n if epoch <= 0:\n raise self.ANNException('epoch must be postitive integer')\n if method == 'gd':\n for _ in range(epoch):\n nodes = self._forward(X)\n self._backpropagate(y, nodes, lr)\n elif method == 'adam':\n alpha = 0.1\n beta1 = 0.5\n beta2 = 0.999\n epsilon = 1e-8\n mt = np.zeros(shape=self.weight.shape)\n vt = np.zeros(shape=self.weight.shape)\n before_err = self._energy(X, y)\n for t in range(1, epoch+1):\n nodes = self._forward(X)\n gt = self._backpropagate(y, nodes, alpha, ret=True)\n mt = beta1*mt + (1-beta1)*gt\n vt = beta2*vt + (1-beta2)*gt**2\n mthat = mt / (1-np.power(beta1, t))\n vthat = vt / (1-np.power(beta2, t))\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\n after_err = self._energy(X, y)\n if 0 < after_err-before_err < quit:\n return\n else:\n before_err = after_err\n else:\n raise self.ANNException('only gd and adam optimizer are supported')","def train_gd(self,f,x,y,learnrate=0.0001,T=1000):\n f = copy.deepcopy(f)\n loss = numpy.zeros(T)\n t = 0\n deltal = -numpy.inf\n while (t<T) and (deltal<1e-7):\n (loss[t],dldw) = self(f,x,y)\n f.w = f.w -learnrate*dldw\n\n if (numpy.remainder(t,100)==0):\n print('Epoch %d: loss=%f' % (t,loss[t]))\n if (t>0):\n deltal = loss[t]-loss[t-1]\n t += 1\n \n return (f,loss)","def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\n n = len_data\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\n prod = np.dot(theta, data_x.transpose())\n\n prod -= data_y\n print(\"pro: data_x\", prod.shape, data_x.shape)\n #prod represent the loss of the hypothesis and true label\n sum_grad = np.dot(prod, data_x)\n print(\"总梯度的值：\",sum_grad.shape)\n\n # batch-gradient descent\n theta = theta -(alpha / n) * sum_grad\n return theta","def train(self):\n df = self.df\n self.scaler = MinMaxScaler()\n self.scaler.fit(df)\n df[df.columns] = self.scaler.transform(df)\n\n\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\n X_train = np.array(X_train)\n X_train.shape = (X_train.shape[0], X_train.shape[2])\n\n self.clf = LogisticRegression().fit(X_train, y_train)\n\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)","def train(self, X, y):\n tf.logging.set_verbosity(\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\n\n X_train, X_test, y_train, y_test = train_test_split(\n X, y, test_size=self.params[\"TEST_SIZE\"], random_state=42, stratify=y)\n\n self.label_list = y.unique()\n\n train_features = self.sentences_to_features(X_train, y_train)\n test_features = self.sentences_to_features(X_test, y_test)\n if DEBUG:\n print(\"Transformation to features completed\")\n\n num_train_steps = int(\n len(train_features) / self.params[\"BATCH_SIZE\"] * self.params[\"NUM_TRAIN_EPOCHS\"])\n num_warmup_steps = int(\n num_train_steps * self.params[\"WARMUP_PROPORTION\"])\n\n run_config = self.run_config_builder()\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\"LEARNING_RATE\"], num_train_steps,\n num_warmup_steps)\n self.estimator = self.estimator_builder(model_fn, run_config)\n\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=True, drop_remainder=False)\n if DEBUG:\n print(\"Beginning Training!\")\n current_time = time.time()\n self.estimator.train(input_fn=train_input_fn,\n max_steps=num_train_steps)\n if DEBUG:\n print(\"Training took time :\", time.time() - current_time,\n \"s, or \", (time.time() - current_time) / 60, \"min\")\n\n self.classifier_trained = True\n\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\n seq_length=self.params[\"MAX_SEQ_LENGTH\"],\n is_training=False, drop_remainder=False)\n\n # apply model on test set and print all metrics\n if DEBUG:\n print(\"Evaluating\")\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)","def linear_classifier(position_array, class_array, n_classes):\n\n # linear classifier\n with tf.Graph().as_default():\n # YOUR CODE FOR PROBLEM 6A GOES HERE\n # Build neural network\n net = tflearn.input_data(shape=[None, 2])\n # 'None' always has to be the first parameter in shape because it tells\n # tensor flow that the number of data points we have can be variable\n # and 2 for 2 input nodes (x and y coordinates)\n\n net = tflearn.fully_connected(net, n_classes, activation='softmax') # layer with 4 nodes and softmax\n net = tflearn.regression(net, loss='categorical_crossentropy') #regression with categorical_crossentropy\n\n # Define model\n model = tflearn.DNN(net)\n new_class_array = np.zeros((len(class_array), 4))\n index = 0\n\n #change to be 4 dimensional\n for x in class_array:\n if x == 0:\n new_class_array[index] = [1,0,0,0]\n elif x == 1:\n new_class_array[index] = [0,1,0,0]\n elif x == 2:\n new_class_array[index]= [0,0,1,0]\n elif x == 3:\n new_class_array[index] = [0,0,0,1]\n index +=1 \n\n # Start training (apply gradient descent algorithm)\n model.fit(position_array, new_class_array, n_epoch=10, batch_size=10, show_metric=True, snapshot_step=1)\n return position_array, new_class_array, model","async def train(gradient_boosting: bool = False) -> bool:\n data = clf.dataset()\n return clf.train(data['X'], data['y'], gradient_boosting)","def train(self, X, y):\r\n # the nearest neighbor classifier simply remembers all the training data\r\n self.Xtr = X\r\n self.ytr = y","def train(self, X, y):\n # the nearest neighbor classifier simply remembers all the training data\n self.Xtr = X\n self.ytr = y","def train(self, X, y):\n # the nearest neighbor classifier simply remembers all the training data\n self.Xtr = X\n self.ytr = y","def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\n # set up classes and make y into a matrix 1 in k encoded\n self.classes = np.sort(np.unique(y))\n num_classes = self.classes.size\n y_as_matrix = np.zeros((y.size, num_classes))\n y_as_matrix[np.arange(y.shape[0]), y] = 1\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\n ### YOUR CODE HERE\n self.w = soft_reg.mini_batch_grad_descent(X, y_as_matrix, reg=reg, lr=lr, epochs=epochs, batch_size=batch_size)\n ### END CODE","def train(self, X, y):\n m,d = X.shape\n D = np.array([1/m] * m)\n for t in range(self.T):\n self.h[t] = self.WL(D,X,y)\n h_t = self.h[t].predict(X)\n epsilon_t = np.sum(np.logical_not(y==h_t) * D)\n self.w[t] = 0.5 * np.log((1/epsilon_t) - 1)\n n = np.sum([D * np.exp(-1 * self.w[t] * y * h_t)])\n D = (D * np.exp(-1 * self.w[t] * y * h_t)) / n","def train(self, train_set, shuffle_batch=True,\n epochs=25, lr_decay=0.95, sqr_norm_lim=9,labels=None,model=None): \n cost = self.negative_log_likelihood(self.y) \n dropout_cost = self.dropout_negative_log_likelihood(self.y)\n # adadelta upgrades: dict of variable:delta\n grad_updates = self.sgd_updates_adadelta(dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\n # shuffle dataset and assign to mini batches.\n # if dataset size is not a multiple of batch size, replicate \n # extra data (at random)\n np.random.seed(3435)\n batch_size = self.batch_size\n if train_set.shape[0] % batch_size > 0:\n extra_data_num = batch_size - train_set.shape[0] % batch_size\n #extra_data = train_set[np.random.choice(train_set.shape[0], extra_data_num)]\n perm_set = np.random.permutation(train_set) \n extra_data = perm_set[:extra_data_num]\n new_data = np.append(train_set, extra_data, axis=0)\n else:\n new_data = train_set\n \n shuffled_data = np.random.permutation(new_data) # Attardi\n n_batches = shuffled_data.shape[0]/batch_size\n # divide train set into 90% train, 10% validation sets\n n_train_batches = int(np.round(n_batches*0.8))\n n_val_batches = n_batches - n_train_batches\n train_set = shuffled_data[:n_train_batches*batch_size,:]\n val_set = shuffled_data[n_train_batches*batch_size:,:] \n # push data to gpu \n # the dataset has the format [word_indices,padding,user,label]\n train_set_x, train_set_y = shared_dataset(train_set[:,:-2], train_set[:,-1]) \n train_set_u = theano.shared(np.asarray(train_set[:,-2],dtype='int32')) \n val_set_x = val_set[:,:-2]\n val_set_u = val_set[:,-2]\n val_set_y = val_set[:,-1]\n # val_set_x, val_set_y = shared_dataset(val_set[:,:-1], val_set[:,-1])\n batch_start = self.index * batch_size\n batch_end = batch_start + batch_size\n\n \n \n # compile Theano functions to get train/val/test errors\n \n # val_model = theano.function([self.index], self.errors(self.y),\n # givens={\n # self.x: val_set_x[batch_start:batch_end],\n # self.y: val_set_y[batch_start:batch_end]},\n # allow_input_downcast=True)\n\n # errors on train set\n if self.Users is not None:\n train_model = theano.function([self.index], cost, updates=grad_updates,\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end],\n self.u: train_set_u[batch_start:batch_end]\n },\n allow_input_downcast = True)\n\n train_error = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end],\n self.u: train_set_u[batch_start:batch_end]},\n allow_input_downcast=True)\n else:\n train_model = theano.function([self.index], cost, updates=grad_updates,\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end]},\n allow_input_downcast = True)\n\n train_error = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end]},\n allow_input_downcast=True)\n\n #FIXME: this is a bit weird\n test_y_pred = self.predict(val_set_x)\n make_preds = theano.function([self.x], test_y_pred, allow_input_downcast=True)\n\n test_error = T.mean(T.neq(test_y_pred, self.y))\n test_model = theano.function([self.x, self.y], test_error, allow_input_downcast=True)\n\n\n # start training over mini-batches\n print 'training...' \n best_val_perf = 0\n test_perf = 0 \n patience = 5\n drops = 0\n prev_val_perf = 0 \n for epoch in xrange(epochs):\n start_time = time.time()\n # FIXME: should permute whole set rather than minibatch indexes\n if shuffle_batch:\n for minibatch_index in np.random.permutation(range(n_train_batches)):\n cost_epoch = train_model(minibatch_index)\n self.set_zero(self.zero_vec) # CHECKME: Why?\n else:\n for minibatch_index in xrange(n_train_batches):\n cost_epoch = train_model(minibatch_index) \n self.set_zero(self.zero_vec)\n train_losses = [train_error(i) for i in xrange(n_train_batches)]\n train_perf = 1 - np.mean(train_losses)\n # test_loss = test_model(val_set_x, val_set_y)\n # test_perf = 1 - test_loss \n # predz = make_preds(val_set_x)\n # val_perf = FmesSemEval(predz, val_set_y, pos_ind, neg_ind)\n val_perf = 0\n info = 'epoch: %i\\%i (%.2f secs) train acc: %.2f %% | val avg fmes: %.2f %%' % (\n epoch,epochs, time.time()-start_time, train_perf * 100., val_perf*100.) \n # from ipdb import set_trace; set_trace()\n if val_perf > prev_val_perf: \n drops=0\n if val_perf >= best_val_perf:\n best_val_perf = val_perf\n info+= \" **\"\n if model:\n # print \"save model\"\n self.save(model)\n # test_loss = test_wmodel(val_set_x, val_set_y)\n # test_perf = 1 - test_loss \n # predz = make_preds(val_set_x)\n # fmes = FmesSemEval(predz, val_set_y, pos_ind, neg_ind)\n # print predz\n # print test_set_y\n # print \"Test performance acc: %.3f | polar fmes:%.3f \" % (test_perf,fmes)\n else: \n drops+=1\n if drops >= patience:\n print \"Ran out of patience...\"\n break\n prev_val_perf = val_perf\n print info\n return test_perf","def non_linear_classifier(position_array, class_array, n_classes):\n with tf.Graph().as_default():\n # YOUR CODE FOR PROBLEM 6C GOES HERE\n # Build neural network\n net = tflearn.input_data(shape=[None, 2])\n # 'None' always has to be the first parameter in shape because it tells\n # tensor flow that the number of data points we have can be variable\n # and 2 for 2 input nodes (x and y coordinates)\n #sgd = tflearn.optimizers.SGD(learning_rate=2.0, lr_decay=0.5, decay_step=100)\n\n net = tflearn.fully_connected(net, 20000, activation='relu') # 20,0000 nodes\n net = tflearn.fully_connected(net, n_classes, activation='softmax') # layer with 4 nodes and softmax\n net = tflearn.regression(net, loss='categorical_crossentropy') #regression with categorical_crossentropy\n\n # Define model\n model = tflearn.DNN(net)\n new_class_array = np.zeros((len(class_array), 4))\n index = 0\n\n #change to be four dimensional\n for x in class_array:\n if x == 0:\n new_class_array[index] = [1,0,0,0]\n elif x == 1:\n new_class_array[index] = [0,1,0,0]\n elif x == 2:\n new_class_array[index]= [0,0,1,0]\n elif x == 3:\n new_class_array[index] = [0,0,0,1]\n index +=1 \n\n # Start training (apply gradient descent algorithm)\n model.fit(position_array, new_class_array, n_epoch=10, batch_size=10, show_metric=True, snapshot_step=1)\n return position_array, new_class_array, model","def stochastic_grad_descent(X, y, alpha=0.1, lambda_reg=1, num_iter=1000, checkin=100):\n num_instances, num_features = X.shape[0], X.shape[1]\n theta = np.ones(num_features) #Initialize theta\n theta_hist = np.zeros((num_iter, num_instances, num_features)) #Initialize theta_hist\n loss_hist = np.zeros((num_iter, num_instances)) #Initialize loss_hist\n epoch = 1\n while epoch < num_iter:\n instance = 1\n while instance < num_instances:\n if alpha == \"1/sqrt(t)\":\n alpha_0 = .01/np.sqrt(instance)\n elif alpha == \"1/t\":\n alpha_0 = .01/float(instance)\n else:\n alpha_0 = alpha\n index = np.random.randint(num_instances)\n vec = np.reshape(X[index,:].T,(1,49))\n grad = compute_regularized_square_loss_gradient(vec,y[index],theta,lambda_reg)\n theta = theta - alpha_0*grad\n theta_hist[epoch][instance] = theta\n loss_hist[epoch][instance] = compute_square_loss(vec,y[index],theta)\n instance += 1\n\n if type(checkin) is int and epoch%checkin==0:\n print(\"completed training epoch {}...\".format(epoch))\n \n epoch += 1\n\n return theta_hist, loss_hist","def loss_and_grad(self, X, y):\n\n # Initialize the loss and gradient to zero.\n loss = 0.0\n grad = np.zeros_like(self.W)\n grad_tmp = np.zeros_like(self.W)\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and the gradient. Store the gradient\n # as the variable grad.\n # ================================================================ #\n \n exp_a = np.zeros((num_classes,num_train))\n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n \n #if i==0:\n grada = np.zeros(X.shape[1])\n \n for j in range(num_classes):\n if j != y[i]:\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \n else: \n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \n\n grad += grad_tmp\n loss += Loss \n \n pass\n\n\n loss /= num_train\n grad /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):","def train_all(X_train_fuse, Y_train, X_dev_fuse, Y_dev, R_train, R_dev, hyperparams):","def fit(self, X, y):\n # Make sure inputs are numpy arrays.\n X = np.array(X)\n y = np.array(y)\n # Add x_0 = 1 to each instance for the bias term.\n X = np.c_[np.ones((X.shape[0], 1)), X]\n # Store number of samples and features in variables.\n n_samples, n_features = np.shape(X)\n self.training_errors = []\n # Initialize weights randomly from normal distribution.\n self.coef_ = np.random.randn(n_features, 1)\n # Batch gradient descent for number iterations = n_iter.\n for _ in range(self.n_iter):\n y_preds = X.dot(self.coef_)\n # Penalty term if regularized (don't include bias term).\n regularization = self.regularization(self.coef_[1:])\n # Calculate mse + penalty term if regularized.\n cost_function = mean_squared_error(y, y_preds) + regularization\n if cost_function > self.threshold:\n break\n self.training_errors.append(cost_function) \n # Regularization term of gradients (don't include bias term).\n gradient_reg = self.regularization.grad(self.coef_[1:])\n # Gradients of loss function.\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\n gradients += gradient_reg\n # Update the weights.\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\n\n return self","def train(self):\n self._stop_gradient = False","def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\"Delta\"):\r\n for i in range(num_epochs):\r\n bse = 0 \r\n for j in range(X.shape[1]//batch_size):\r\n x_bs = X[:,bse:bse+batch_size]\r\n y_bs = y[:,bse:bse+batch_size]\r\n diff = np.subtract(y_bs, self.predict(x_bs))\r\n bse+=batch_size\r\n\r\n if learning.lower() == \"filtered\":\r\n self.weights = (1-gamma)*self.weights + alpha*(np.dot(y_bs, x_bs.T))\r\n elif learning.lower() == \"delta\":\r\n self.weights = self.weights + alpha*(np.dot(diff, x_bs.T))\r\n\r\n else:\r\n self.weights = self.weights + alpha*(np.dot(self.predict(x_bs), x_bs.T))","def train_logistic_regression(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> LogisticRegressionClassifier:\n lr = LogisticRegressionClassifier(feat_extractor.corpus_length, feat_extractor)\n alpha = 1e0\n # beta = 1e-4\n for epoch in range(8):\n loss = 0.\n acc = 0\n indices = np.arange(len(train_exs))\n np.random.shuffle(indices)\n for i in indices:\n feat = feat_extractor.feats[i]\n sentimentExample = train_exs[i]\n y = sentimentExample.label\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z) \\\n # + beta * np.expand_dims(lr.w, axis=0).dot(np.expand_dims(lr.w, axis=1))[0, 0]\n predict = int(feat.dot(np.expand_dims(lr.w, axis=1))[0, 0] > 0)\n acc += (predict == y)\n grad = (z - y) * feat.toarray()[0] # + 2 * beta * lr.w\n lr.w = lr.w - alpha * grad\n print(\"epoch {:d}, loss: {:f}, accuracy: {:f}\".format(epoch, loss / len(train_exs), acc / len(train_exs)))\n\n for i in indices:\n feat = feat_extractor.feats[i]\n sentimentExample = train_exs[i]\n y = sentimentExample.label\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z)\n print(\"training loss: {:f}\".format(loss / len(train_exs)))\n\n return lr","def train(self, X, y, X_val, y_val,\n alpha=1e-3, alpha_decay=0.95,\n reg=1e-5, num_iters=100,\n batch_size=100):\n num_train = X.shape[0]\n iteration = max(num_train / batch_size, 1)\n\n loss_train = []\n train_acc = []\n val_acc = []\n\n for it in range(num_iters):\n print('iteration '+str(it))\n data_batch = None\n label_batch = None\n \n #########################################################################\n # create a random batch of data and labels for\n indx = np.random.permutation(len(X))\n data, labels = X[indx], y[indx]\n data_batch = data[0:batch_size]\n label_batch = labels[0:batch_size]\n #########################################################################\n pass\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n # calculate loss and gradients\n loss, gradient = self.loss(data_batch, y=label_batch, reg=reg)\n loss_train.append(loss)\n #########################################################################\n # update weights and biases which stored in the slef.p_net regarding \n # to gradient dictionary.\n self.p_net['W1'] -= alpha * gradient['W1']\n self.p_net['b1'] -= alpha * gradient['b1']\n self.p_net['W2'] -= alpha * gradient['W2']\n self.p_net['b2'] -= alpha * gradient['b2']\n #########################################################################\n pass\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n if it % 100 == 0:\n print ('iteration %d / %d: loss %f' % (it, num_iters, loss))\n \n if it % iteration == 0:\n # Check accuracy\n train_acc_ = (self.predict(data_batch) == label_batch).mean()\n val_acc_ = (self.predict(X_val) == y_val).mean()\n train_acc.append(train_acc_)\n val_acc.append(val_acc_)\n\n alpha *= alpha_decay\n\n return {\n 'loss_train': loss_train,\n 'train_acc': train_acc,\n 'val_acc': val_acc,\n }","def train(self, X, y, learning_rate=1e-3, num_iters=100,\n batch_size=200, verbose=True):\n num_train, dim = X.shape\n\n if self.w is None:\n self.w = 0.001 * np.random.randn(dim)\n\n loss_history = []\n\n # 将feature与label连起来，方便后面batch的划分\n all_data = list(zip(X, y))\n\n for it in xrange(num_iters):\n X_batch = None\n y_batch = None\n\n #########################################################################\n # TODO: #\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n\n # batch_data = np.random.choice(all_data, batch_size, False) \n # error: ValueError: a must be 1-dimensional \n # 查询相关api貌似该方法不能用于数组中元素为元组情况下的选取\n batch_data = random.sample(all_data, batch_size)\n X_batch, y_batch = zip(*batch_data)\n X_batch = np.array(X_batch)\n y_batch = np.array(y_batch)\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n # evaluate loss and gradient\n\n loss, grad = self.loss(X_batch, y_batch)\n loss_history.append(loss)\n\n # perform parameter update\n #########################################################################\n # TODO: #\n # Update the weights using the gradient and the learning rate. #\n #########################################################################\n self.w += float(learning_rate) * np.array(grad)\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n if verbose and (it % 1000 == 0 or it == num_iters - 1):\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def fit(self, X, y, max_iter=MAX_ITER):\n X = self.normalize_data(X)\n X = self.add_bias(X)\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n start = time.time()\n cost_function = 0\n for t in range(n_tasks):\n #print('Training {} task with lasso regression'.format(t))\n lasso = Lasso(alpha=self.lambda_1, positive=self.positive, max_iter=max_iter)\n lasso.fit(X[t], y[t])\n W[:, t] = lasso.coef_\n cost_function += np.linalg.norm(np.dot(X[t], W[:, t]) - y[t]) \\\n + sum(abs(W[:, t]))\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def train(self, X, y):\n pass","def evaluate(self, train_set, test_set, shuffle_batch=True,\n epochs=25, lr_decay=0.95, sqr_norm_lim=9,labels=None,model=None): \n cost = self.negative_log_likelihood(self.y) \n dropout_cost = self.dropout_negative_log_likelihood(self.y)\n # adadelta upgrades: dict of variable:delta\n grad_updates = self.sgd_updates_adadelta(dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\n # shuffle dataset and assign to mini batches.\n # if dataset size is not a multiple of batch size, replicate \n # extra data (at random)\n np.random.seed(3435)\n batch_size = self.batch_size\n if train_set.shape[0] % batch_size > 0:\n extra_data_num = batch_size - train_set.shape[0] % batch_size\n #extra_data = train_set[np.random.choice(train_set.shape[0], extra_data_num)]\n perm_set = np.random.permutation(train_set) \n extra_data = perm_set[:extra_data_num]\n new_data = np.append(train_set, extra_data, axis=0)\n else:\n new_data = train_set\n \n shuffled_data = np.random.permutation(new_data) # Attardi\n n_batches = shuffled_data.shape[0]/batch_size\n # divide train set into 90% train, 10% validation sets\n n_train_batches = int(np.round(n_batches*0.8))\n n_val_batches = n_batches - n_train_batches\n train_set = shuffled_data[:n_train_batches*batch_size,:]\n val_set = shuffled_data[n_train_batches*batch_size:,:] \n # push data to gpu \n # the dataset has the format [word_indices,padding,user,label]\n train_set_x, train_set_y = shared_dataset(train_set[:,:-2], train_set[:,-1]) \n train_set_u = theano.shared(np.asarray(train_set[:,-2],dtype='int32')) \n # val_set_x = val_set[:,:-2]\n # val_set_u = val_set[:,-2]\n # val_set_y = val_set[:,-1]\n val_set_x, val_set_y = shared_dataset(val_set[:,:-2], val_set[:,-1])\n val_set_u = theano.shared(np.asarray(val_set[:,-2],dtype='int32')) \n test_set_x = test_set[:,:-2]\n test_set_u = test_set[:,-2]\n test_set_y = test_set[:,-1] \n batch_start = self.index * batch_size\n batch_end = batch_start + batch_size\n\n # compile Theano functions to get train/val/test errors\n \n \n test_y_pred = self.predict(test_set_x,test_set_u)\n test_error = T.mean(T.neq(test_y_pred, self.y))\n # errors on train set\n if self.Users is not None:\n train_model = theano.function([self.index], cost, updates=grad_updates,\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end],\n self.u: train_set_u[batch_start:batch_end]\n },\n allow_input_downcast = True)\n\n train_error = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end],\n self.u: train_set_u[batch_start:batch_end]},\n allow_input_downcast=True)\n val_model = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: val_set_x[batch_start:batch_end],\n self.y: val_set_y[batch_start:batch_end], \n self.u: val_set_u[batch_start:batch_end]},\n allow_input_downcast=True)\n test_model = theano.function([self.x, self.u, self.y], test_error, allow_input_downcast=True)\n else:\n train_model = theano.function([self.index], cost, updates=grad_updates,\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end]},\n allow_input_downcast = True)\n\n train_error = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: train_set_x[batch_start:batch_end],\n self.y: train_set_y[batch_start:batch_end]},\n allow_input_downcast=True)\n\n val_model = theano.function([self.index], self.errors(self.y),\n givens={\n self.x: val_set_x[batch_start:batch_end],\n self.y: val_set_y[batch_start:batch_end]},\n allow_input_downcast=True)\n test_model = theano.function([self.x, self.y], test_error, allow_input_downcast=True)\n\n # start training over mini-batches\n print 'training...' \n best_val_perf = 0\n test_perf = 0 \n patience = 5\n drops = 0\n prev_val_perf = 0 \n for epoch in xrange(epochs):\n start_time = time.time()\n # FIXME: should permute whole set rather than minibatch indexes\n if shuffle_batch:\n for minibatch_index in np.random.permutation(range(n_train_batches)):\n cost_epoch = train_model(minibatch_index)\n self.set_zero(self.zero_vec) # CHECKME: Why?\n else:\n for minibatch_index in xrange(n_train_batches):\n cost_epoch = train_model(minibatch_index) \n self.set_zero(self.zero_vec)\n train_losses = [train_error(i) for i in xrange(n_train_batches)]\n train_perf = 1 - np.mean(train_losses)\n val_losses = [val_model(i) for i in xrange(n_val_batches)]\n val_perf = 1 - np.mean(val_losses) \n info = 'epoch: %i\\%i (%.2f secs) train acc: %.2f %% | val acc: %.2f %%' % (\n epoch,epochs, time.time()-start_time, train_perf * 100., val_perf*100.) \n # from ipdb import set_trace; set_trace()\n if val_perf > prev_val_perf: \n drops=0\n if val_perf >= best_val_perf:\n best_val_perf = val_perf\n info+= \" **\"\n if model:\n # print \"save model\"\n self.save(model)\n if self.Users is not None:\n test_loss = test_model(test_set_x, test_set_u, test_set_y)\n else:\n test_loss = test_model(test_set_x, test_set_y)\n test_perf = 1 - test_loss \n else: \n drops+=1\n if drops >= patience:\n print \"Ran out of patience...\"\n break\n prev_val_perf = val_perf\n print info\n # set_trace() \n return test_perf","def learn(self, Xtrain, ytrain):\n pass\n self.weights = np.zeros(Xtrain.shape[1],)\n\n ### YOUR CODE HERE\n \n lmbd = self.params['lamb']\n \n numsamples = Xtrain.shape[0]\n # Xless = Xtrain[:,self.params['features']]\n Xless = Xtrain\n self.weights = np.random.rand(Xless.shape[1])\n err = 10000;\n #cw =0;\n tolerance = 10*np.exp(-4)\n i=0;\n \n \n w1 = self.weights\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\n # print(cw)\n errors = []\n runtm = []\n epch = []\n \n err = 1\n iteration= 1000\n #tm= time.time()\n while (abs(cw-err)>tolerance) and (i <iteration):\n err = cw\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\n obj = cw\n j=0\n ita = -1* self.params['stepsize']\n w = self.weights\n # w1 = np.add(w,np.dot(ita,g))\n while(j<iteration):\n w1 = np.add(w,np.dot(ita,g))\n # cw_v =(np.dot(Xless, w1)-ytrain)\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, w1.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\n ## print (cw)\n \n if(cw<np.absolute(obj-tolerance)): ############################################\n break\n ita = 0.7*ita\n j=j+1\n \n if(j==iteration):\n self.weights=w\n ita =0\n else:\n self.weights = w1\n \n # cw_v =(np.dot(Xless, self.weights)-ytrain)\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\n cw_v = np.dot(Xless, self.weights.T)\n cw = self.logit_cost(cw_v, Xless, ytrain)\n #tm1 = time.time()-tm\n #runtm.append(tm1)\n #err = cw\n errors.append(err)\n i=i+1\n epch.append(i)","def learn2_sgd():\n\n sgd.fit(vector_training,sentiment_training) ##fits the training data of vector tweets and sentiments using SGDClassifier\n correct = 0\n for i in range(vector_testing.shape[0]): ##using the testing, data see how accurate SGDC is\n prediction = sgd.predict(vector_testing[i])\n sentiment = sentiment_testing[i]\n if prediction[0] == sentiment:\n correct +=1\n \n accuracy = correct/vector_testing.shape[0]\n print('Stochastic Gradient Descent Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##prints the accuracy of the algorithm","def train(self, network, training_examples, iterations, unsupervised=False):\n if unsupervised:\n # For now this means we are training a sparse autoencoder.\n # Therefore, we need to keep a running estimate of the\n # \"sparsity\" of a node, where we try to keep the activation\n # of the node stay close to a small value near 0 known as\n # rho (Greek lower case p) or the 'sparsity parameter',\n # which we will set to 0.05.\n # This forces the network to learn the smallest set of features\n # necessary to accurately build a close estimate of the original\n # input vector\n # In this case, we set the input vector equal to the target vector,\n # and usually set a smaller value for the number of hidden nodes\n # Then perform normal backpropagation, and during that, for each\n # hidden node, also update the rho_estimate, and then update the\n # threshold value\n rho = 0.05\n rho_estimates = [0] * len(network.layers[0].neurons) # set to 0 for each node\n beta = 0.2 # the learning rate for updating the threshold terms\n for iteration_counter in range(iterations):\n random.shuffle(training_examples)\n # for each row of data\n for training_example in training_examples:\n input_vector = training_example[0]\n target_output_vector = training_example[1]\n # prime the network on this row of input data\n # -this will cause output (activation) values to be\n # set for each neuron\n network.forward(input_vector)\n\n # Note: next_layer_deltas is a vector of the single\n # delta values for each node in the next\n # (forward) layer\n next_layer_deltas = []\n next_layer_weights = []\n isOutputLayer = True\n for layer in reversed(network.layers): # iterate backwards\n this_layer_deltas = [] # values from current layer\n this_layer_weights = []\n for j, neuron in enumerate(layer.neurons):\n derivative = neuron.activation_function.derivative\n # The output layer neurons are treated slightly\n # different than the hidden neurons\n if isOutputLayer:\n if neuron.activation_function.name == \"logistic\":\n # derivative simplifies down to just\n # subtracting the target from the\n # hypothesis\n delta = neuron.output - target_output_vector[j]\n else: # Tanh or Linear\n delta = (neuron.output-target_output_vector[j])*derivative(neuron.output)\n else: # for the hidden layer neurons\n # Need to sum the products of the delta of\n # a neuron in the next (forward) layer and the\n # weight associated with the connection between\n # this hidden layer neuron and that neuron.\n # This will basically determine how much this\n # neuron contributed to the error of the neuron\n # it is connected to\n # Note: next_layer_deltas is a vector of the \n # single delta values for each node in the next\n # (forward) layer\n sum_value = 0.0\n for next_delta, weights in zip(next_layer_deltas,\n next_layer_weights):\n sum_value += weights[j] * next_delta\n delta = (derivative(neuron.output) *\n sum_value)\n # now store the delta and the list of weights\n # for this neuron into these storage lists for the\n # whole layer\n this_layer_deltas.append(delta)\n this_layer_weights.append(neuron.weights)\n # Now, compute the gradient (partial deriv of cost\n # func, J, w/ respect to parameter ij) for each\n # weight_ij (parameter_ij) associated with\n # this neuron\n for ij, input_ij in enumerate(neuron.input_vector):\n # compute gradient (partial deriv of cost J w/\n # respect to parameter ij)\n # Note: index ij means from a previous\n # layer node i to this layer node j\n # Then Gradient Descent: multiply by the learning\n # rate, and subtract from the current value\n # Note: Subtract in order to minimize error, since\n # partial derivs point in direction of gradient\n # AScent\n gradient_ij = delta * input_ij\n neuron.weights[ij] -= self.learning_rate * gradient_ij\n # Now, compute the gradient (partial deriv of cost\n # func, J, with respect to parameter ij) for the\n # threshold value (parameter_0j), by using a \"1\" as\n # the threshold \"input value\"\n # -Note: index 0j means from a previous\n # layer threshold node 0 (threshold always has\n # index i=0) to this layer node j\n # -can also think of it as the threshold being\n # internal to this neuron\n gradient_0j = delta * 1\n neuron.threshold -= self.learning_rate * gradient_0j\n if unsupervised and not isOutputLayer:\n rho_estimates[j] = (0.999*rho_estimates[j] +\n 0.001*neuron.output)\n neuron.threshold -= (self.learning_rate * beta *\n (rho_estimates[j] - rho))\n # Once this layer is done, store the gradients and weights\n # from the current layer for the next layer iteration\n # (moving backwards)\n next_layer_deltas = this_layer_deltas\n next_layer_weights = this_layer_weights\n isOutputLayer = False\n # Note: this is after the while loop\n self.iterations = iteration_counter","def __init__(self, train_data, validation=None, initial_weight=None,\n loss_function_name='mse', cal_weight='gradient',\n regularizer=None, regularizer_p=None):\n self.train_x = train_data[1]\n self.train_y = train_data[0]\n\n self.set_valid(validation)\n\n ''' Define the progress of history here '''\n self.losses = []\n self.iterations = 0\n self.weights = []\n self.misclass_rate = []\n\n ''' Define loss, weight calculation, regularizer '''\n self.loss_function = get_loss_function(loss_function_name)\n self.loss_function_name = loss_function_name\n self.calculate_weight = cal_weight\n self.regularizer = Regularizer.get_regularizer(regularizer, regularizer_p)\n self.regularizer_p = regularizer_p\n\n # Asserting degree\n if len(self.train_x.shape) > 1:\n degree = self.train_x.shape[1]\n else:\n degree = 1\n\n # Initialize the weight for linear model.\n if initial_weight is not None:\n self.weights.append(initial_weight)\n else:\n self.weights.append(np.random.rand(degree))","def SGD(self, tr_d, va_d, epochs, lr, relz=\"\", lmbda=0.0, mu=0.0,perc=1.0):\n print \"Training the network with SGD......\"\n trlen = len(tr_d)\n batch_size = 10\n j = 0\n accuracy = []\n while j < epochs:\n random.shuffle(tr_d)\n batches = [tr_d[k:k+batch_size] for k in xrange(0,trlen,batch_size)]\n for tr_batch in batches:\n if(relz[0:2] != \"DP\"):\n self.update_network(tr_batch,lr, relz, lmbda, mu)\n else:\n self.update_network_dp(tr_batch,lr,relz[2:], lmbda,perc, mu)\n acy = self.Evaluate(va_d)\n accuracy.append(acy)\n if (va_d):\n print \"Epoch {0}: {1}/{2}\".format(j, acy, len(va_d))\n else:\n print \"Epoch {0}:\".format(j)\n j += 1\n np.save(\"test_acy_%s_qinit_1.npy\"%(relz), accuracy)","def train_perceptron(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> PerceptronClassifier:\n raise Exception(\"Must be implemented\")","def train_perceptron(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> PerceptronClassifier:\n raise Exception(\"Must be implemented\")","def fit(self, X, y_class, y_loc):\n epochs = self.epochs\n alpha = self.alpha\n\n tensor_X = torch.from_numpy(X)\n t_y_class = torch.from_numpy(y_class)\n t_y_class = t_y_class.float()\n t_y_loc = torch.from_numpy(y_loc)\n \n learning_rate = 1e-3\n optimizer = torch.optim.Adagrad(self.Net.parameters(), lr=learning_rate)\n\n for i in range(epochs): \n out_1, out_2 = self.Net(tensor_X)\n loss_1 = self.criterion_1(out_1, t_y_class)\n loss_2 = self.criterion_2(out_2, t_y_loc)\n loss = alpha * loss_1 + (1 - alpha) * loss_2\n\n optimizer.zero_grad()\n loss.backward()\n optimizer.step()\n \n params_dict = self.Net.state_dict()\n w1 = params_dict['linear1.weight'].detach().numpy()\n w1 = w1.T\n b1 = params_dict['linear1.bias'].detach().numpy()\n\n w2 = params_dict['linear2.weight'].detach().numpy()\n w2 = w2.T\n b2 = params_dict['linear2.bias'].detach().numpy()\n\n w3 = params_dict['linear3_1.weight'].detach().numpy()\n w3 = w3.T \n b3 = params_dict['linear3_1.bias'].detach().numpy()\n\n w4 = params_dict['linear3_2.weight'].detach().numpy()\n w4 = w4.T \n b4 = params_dict['linear3_2.bias'].detach().numpy()\n\n w5 = params_dict['linear4_1.weight'].detach().numpy()\n w5 = w5.T\n b5 = params_dict['linear4_1.bias'].detach().numpy()\n\n w6 = params_dict['linear4_2.weight'].detach().numpy()\n w6 = w6.T \n b6 = params_dict['linear4_2.bias'].detach().numpy()\n\n self.set_model_params(w1, b1, w2, b2, w3, b3, w4, b4, w5, b5, w6, b6)\n\n return","def trainNet():","def gradient_descent(self, X ,eta, tol,iter):\n gd=[]\n gd_x=[X]\n iteration=0\n # current_pt=X\n first_derivative=sym.diff(self.gdfunc)\n #print(first_derivative)\n x=sym.Symbol('x')\n first_derivative=sym.lambdify(x,first_derivative)\n learn_rate=eta\n \n \n prev_x=X\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n #print(\"prev_x = \",prev_x,\" Next x = \",new_x)\n for i in range(iter):\n prev_x=new_x\n #print(prev_x)\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\n gd_x.append(new_x)\n # print(\"x = \",new_x,\"Gradient =\",learn_rate*self.func(prev_x))\n if abs(self.func(new_x)) <= self.func(tol) :\n break\n iteration=iteration+1\n #print(\"Best at GD x= \",new_x)\n gd.append(gd_x)\n gd.append(new_x)\n gd.append(iteration)\n\n return gd","def train(network,X,y):\r\n \r\n # Get the layer activations\r\n layer_activations = forward(network,X)\r\n logits = layer_activations[-1]\r\n \r\n # Compute the loss and the initial gradient\r\n loss = softmax_crossentropy_with_logits(logits,y)\r\n loss_grad = grad_softmax_crossentropy_with_logits(logits,y)\r\n \r\n for i in range(1, len(network)):\r\n loss_grad = network[len(network) - i].backward(layer_activations[len(network) - i - 1], loss_grad)\r\n #loss_grad = network[0].backward(X, loss_grad)\r\n return np.mean(loss)","def __trainLocal__(self, featureVals, targetVals):\n pass","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n\n cur_cost = float(\"inf\")\n tolerance = 10 ** -6\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n while abs(new_cost - cur_cost) > tolerance:\n cur_cost = new_cost\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\n self.weights = self.weights - (step_size * gradient)\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\n\n #Format properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def train(self):\n learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,self.decay_rate, staircase=True)\n self.learning_rate_=learning_rate\n #noise_std_dev = tf.constant(0.3) / (tf.sqrt(tf.cast(tf.constant(1) + self.global_step, tf.float32))) #gradient_noise_scale=noise_std_dev\n train_op = tf_contrib.layers.optimize_loss(self.loss_val, global_step=self.global_step,\n learning_rate=learning_rate, optimizer=\"Adam\",clip_gradients=self.clip_gradients)\n return train_op","def fit(self, X, y, max_iter=MAX_ITER):\n X = self.normalize_data(X)\n X = self.add_bias(X)\n n_tasks = len(X)\n n_feats = X[0].shape[1]\n W = np.random.randn(n_feats, n_tasks)\n start = time.time()\n cost_function = 0\n for t in range(n_tasks):\n #print('Training {} task with lasso regression'.format(t))\n lasso = LogisticRegression(C=self.lambda_1,\n penalty='l1',\n max_iter=max_iter)\n lasso.fit(X[t], y[t])\n W[:, t] = lasso.coef_\n stop = time.time() - start\n self.W = W\n return W, np.array([cost_function]), stop","def stochastic_gradient_descent(X, y, max_niter=100):\n m, n = X.shape\n w = np.zeros((n, 1))\n\n for i in range(max_niter):\n data_indices = list(range(m))\n for j in range(m):\n alpha = 4.0 / (i + j + 1.0) + 0.01\n rand_idx = int(np.random.uniform(0, len(data_indices)))\n h = sigmoid(np.dot(X[rand_idx, :], w))\n error = h - float(y[rand_idx])\n w = w - alpha * np.outer(X[rand_idx, :], error)\n print('{0} iterations with error {1} weight {2} alpha={3}'.format(i, error, w, alpha))\n del(data_indices[rand_idx])\n classify.w = w\n return w","def train(self, training_steps=10):","def gradient_model (self, x, initial_weights = None, \\\n step_size = 5.0e-6, tol = 2.5e+7, n_iters = 501, l2 = 0):\n # setup initial intercept, slope, iter number and rss\n if initial_weights is None:\n weights = self.initial_weight\n else:\n weights = initial_weights\n # Compute indicator value for (y_i = +1)\n indicators = np.array([int (i) for i in (self.train_output_y==1)])\n for itr in range(n_iters):\n # Predict P(y_i = +1|x_1,w) using your predict_probability() function\n _, pred_probs = self.predict_probability(self.train_feature_x, weights)\n \n # Compute the errors as indicator - predictions\n errors = indicators - pred_probs\n\n #Update the weights:\n derivative = self.feature_derivative(errors, weights, l2)\n weights = weights + derivative * (step_size) \n \n #check if converged\n #todo\n \"\"\"\n # Checking whether log likelihood is increasing\n if itr <= 15 or (itr <= 100 and itr % 10 == 0) or (itr <= 1000 and itr % 100 == 0) \\\n or (itr <= 10000 and itr % 1000 == 0) or itr % 10000 == 0:\n lp = self.compute_log_likelihood(indicators,weights)\n print 'iteration %*d: log likelihood of observed labels = %.8f' % \\\n (int(np.ceil(np.log10(n_iters))), itr, lp)\n \"\"\"\n \n #check weights\n #print \"\\n\"\n #print \"The weights for features: \", weights\n #final prediction\n preds = self.prediction(x, weights)\n return preds, weights","def fit(self, x, y): \n # *** START CODE HERE ***\n y = y.reshape(y.shape[0], 1)\n y_0 = (1 - y).reshape(y.shape)\n m = y.shape[0]\n m_0 = np.asscalar(np.sum(y_0))\n m_1 = np.asscalar(np.sum(y))\n # Find phi, mu_0, mu_1, and sigma\n phi = np.sum(y) / m\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\n # Write theta in terms of the parameters\n sigma_inv = np.linalg.inv(sigma)\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\n # Compute cost\n x_0 = np.zeros((x.shape[0], 1)) + 1\n x_train = np.concatenate((x_0.T, x.T))\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\n if self.verbose:\n print(\"Cost: \" + str(cost))\n # *** END CODE HERE ***","def train():\n\n ### DO NOT CHANGE SEEDS!\n # Set the random seeds for reproducibility\n np.random.seed(42)\n\n ## Prepare all functions\n # Get number of units in each hidden layer specified in the string such as 100,100\n if FLAGS.dnn_hidden_units:\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\",\")\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\n else:\n dnn_hidden_units = []\n\n # Get negative slope parameter for LeakyReLU\n neg_slope = FLAGS.neg_slope\n\n ########################\n # PUT YOUR CODE HERE #\n #######################\n import matplotlib.pyplot as plt\n\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\n train = data['train']\n test = data['test']\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\n\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\n loss_module = CrossEntropyModule()\n\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\n\n images_test = test.images\n labels_test = test.labels\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\n\n for i in range(0, FLAGS.max_steps):\n if PRINTS:\n print('iter', i+1, end='\\r')\n images, labels = train.next_batch(FLAGS.batch_size) \n images = np.reshape(images, (images.shape[0], dim_x))\n\n pred = mlp.forward(images)\n loss = loss_module.forward(pred, labels)\n loss_grad = loss_module.backward(pred, labels)\n mlp.backward(loss_grad)\n\n for module in reversed(mlp.modules):\n if isinstance(module, LinearModule):\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\n if (i+1) % FLAGS.eval_freq == 0:\n pred_test = mlp.forward(images_test)\n loss_train[i // FLAGS.eval_freq] = loss\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\n if PRINTS:\n print()\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\n\n if PLOTS:\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\n fig.suptitle('Training curves for Numpy MLP\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\n\n ax[0].set_title('Loss')\n ax[0].set_ylabel('Loss value')\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[0].plot(loss_train, label='Train')\n ax[0].plot(loss_test, label='Test')\n ax[0].legend()\n\n ax[1].set_title('Accuracy')\n ax[1].set_ylabel('Accuracy value')\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\n ax[1].plot(accuracy_test, label='Test')\n ax[1].legend()\n plt.show()\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def train(self, verbose=True):\n\n\n learned = False\n iteration = 0\n\n from util.loss_functions import DifferentError\n loss = DifferentError()\n\n\n\n\n\n # Train for some epochs if the error is not 0\n while not learned:\n # x ist ein Bild bestehend aus einem Label (erster Eintrag) und 784 Pixeln\n # t ist das Zielergebnis von x (überprüfbar mit dem Label)\n # o ist der tatsächliche Ergebnis von x\n # w ist der Gewichtsvektor\n # Als Aktivierungsfunktion verwenden wir die Sigmoid Funktion\n # Das Training wird dann beendet, sobald das Fehlerkriterium konvergiert\n\n totalError = 0\n\n output = []\n labels = self.trainingSet.label\n inputs = self.trainingSet.input\n\n # iteriere für jede Instanz im Trainingsset x € X\n for input in inputs:\n # Ermittle O_x = sig(w*x)\n output.append(self.fire(input))\n\n # Ermittle Fehler AE = tx - ox\n error = loss.calculateError(np.array(labels), np.array(output))\n\n # grad = [0]\n grad = np.zeros(len(self.trainingSet.input[0]))\n grad2 = np.zeros(len(self.trainingSet.input[0]))\n\n for e, input, out in zip(error, inputs, output):\n activationPrime = Activation.getDerivative(activationName)(np.dot(np.array(input), self.weight))\n #grad += np.multiply( np.multiply( input, e), activationPrime)\n grad += np.multiply( input, e)\n\n # Update grad = grad + errorPrime * x * activationPrime\n\n\n\n # print grad - grad2\n #print \"Error: \" + str(error) + \" Grad: \" + str(grad)\n\n # update w: w <- w + n*grad\n self.updateWeights(grad)\n\n\n iteration += 1\n totalError = error.sum()\n\n if verbose:\n logging.info(\"Epoch: %i; Error: %i\", iteration, totalError)\n\n if abs(totalError) < 0.01 or iteration >= self.epochs:\n # stop criteria is reached\n learned = True\n\n pass","def train_classifier(train_data, dev_data, num_iterations, learning_rate, params):\n for I in range(num_iterations):\n cum_loss = 0.0 # total loss in this iteration.\n random.shuffle(train_data)\n for label, features in train_data:\n x = feats_to_vec(features) # convert features to a vector.\n y = L2I[label] # convert the label to number if needed.\n loss, grads = ll.loss_and_gradients(x, y, params)\n cum_loss += loss\n # update weights and bias\n params = [params[i] - learning_rate * grads[i] for i in range(len(grads))]\n train_loss = cum_loss / len(train_data)\n train_accuracy = accuracy_on_dataset(train_data, params)\n dev_accuracy = accuracy_on_dataset(dev_data, params)\n print(I, train_loss, train_accuracy, dev_accuracy)\n return params","def SGD(self, X_train, Y_train, X_validation, Y_validation, epochs, mini_batch_size, learning_rate, decay):\n \n training_data = zip(X_train, Y_train)\n validation_data = zip(X_validation, Y_validation)\n\n \n \"\"\"Take the training data and make a list out of it\"\"\"\n training_data = list(training_data)\n \n \"\"\"Check if there is data in the test_data\"\"\"\n if validation_data:\n validation_data = list(validation_data)\n n_validation_data = len(validation_data)\n \n \"\"\"\n Mini-batches: Each mini-batch contains mini_batch_size elements from the training set.\n \n Splits the training data into mini-bachtes, and for each mini-batches we train the network. \n \n \"\"\" \n\n# Updated for the testing\n# ========================\n mini_batches = []\n high_score = [0,0]\n for j in range(epochs):\n random.shuffle(training_data)\n for k in range(0, len(training_data), mini_batch_size):\n mini_batches.append(training_data[k:k+mini_batch_size])\n for mini_batch in mini_batches:\n self.update_mini_batch(mini_batch, learning_rate)\n if validation_data:\n new_score = self.evaluate(X_validation, Y_validation)\n if high_score[0] < new_score:\n high_score[0] = new_score\n high_score[1] = j + 1\n learning_rate = learning_rate * (1-decay)\n \n return high_score[0], high_score[1]\n# ========================\n\n\n \"\"\"\n Update the network's weights and biases by applying\n gradient descent using backpropagation to a single mini batch.\n The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``\n is the learning rate.\"\"\"","def gradient_descent(g_dd, y_train, loss, g_td=None):\n\n output_dimension = y_train.shape[-1]\n\n g_dd = empirical.flatten_features(g_dd)\n\n def fl(fx):\n \"\"\"Flatten outputs.\"\"\"\n return np.reshape(fx, (-1,))\n\n def ufl(fx):\n \"\"\"Unflatten outputs.\"\"\"\n return np.reshape(fx, (-1, output_dimension))\n\n # These functions are used inside the integrator only if the kernel is\n # diagonal over the logits.\n ifl = lambda x: x\n iufl = lambda x: x\n\n # Check to see whether the kernel has a logit dimension.\n if y_train.size > g_dd.shape[-1]:\n out_dim, ragged = divmod(y_train.size, g_dd.shape[-1])\n if ragged or out_dim != y_train.shape[-1]:\n raise ValueError()\n ifl = fl\n iufl = ufl\n\n y_train = np.reshape(y_train, (-1))\n grad_loss = grad(functools.partial(loss, y_hat=y_train))\n\n if g_td is None:\n dfx_dt = lambda unused_t, fx: -ifl(np.dot(g_dd, iufl(grad_loss(fx))))\n\n def predict(dt, fx=0.):\n r = ode(dfx_dt).set_integrator('dopri5')\n r.set_initial_value(fl(fx), 0)\n r.integrate(dt)\n\n return ufl(r.y)\n else:\n g_td = empirical.flatten_features(g_td)\n\n def dfx_dt(unused_t, fx, train_size):\n fx_train = fx[:train_size]\n dfx_train = -ifl(np.dot(g_dd, iufl(grad_loss(fx_train))))\n dfx_test = -ifl(np.dot(g_td, iufl(grad_loss(fx_train))))\n return np.concatenate((dfx_train, dfx_test), axis=0)\n\n def predict(dt, fx_train=0., fx_test=0.):\n r = ode(dfx_dt).set_integrator('dopri5')\n\n fx = fl(np.concatenate((fx_train, fx_test), axis=0))\n train_size, output_dim = fx_train.shape\n r.set_initial_value(fx, 0).set_f_params(train_size * output_dim)\n r.integrate(dt)\n fx = ufl(r.y)\n\n return fx[:train_size], fx[train_size:]\n\n return predict","def learn(self, Xtrain, ytrain):\n self.cost_data = []\n self.weights = np.zeros((len(self.params['features']), 1))\n numsamples = Xtrain.shape[0]\n Xless = Xtrain[:,self.params['features']]\n y = ytrain[:, np.newaxis]\n epochs = 1000\n\n for epoch in range(epochs):\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\n data_set = np.append(Xless, y, axis=1)\n np.random.shuffle(data_set)\n Xless = data_set[:, 0:data_set.shape[1] - 1]\n y = data_set[:, -1, np.newaxis]\n for t in range(numsamples):\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\n step_size = 0.01 / (epoch + 1)\n self.weights = self.weights - (step_size * gradient)\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\n #Format the array properly for the error function\n self.weights = np.ndarray.flatten(self.weights)","def fast_loss_and_grad(self, X, y):\n loss = 0.0\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\n \n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the softmax loss and gradient WITHOUT any for loops.\n # ================================================================ #\n \n num_train = X.shape[0]\n num_classes = self.W.shape[0]\n \n# # vectorized loss calculation #\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\n \n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\n# #print(exp_a[:,:3])\n# #print(y[:3])\n# #print(y_exp[:3])\n \n# tt = np.sum(exp_a,axis=0)\n# tt2 = np.divide(tt,y_exp)\n# print(num_train)\n# tt3 = np.power(tt2,1/num_train)\n# loss = np.log(np.prod(tt3))\n \n \n \n \n (C, D) = self.W.shape\n N = X.shape[0]\n\n scores = np.dot(self.W, X.T)\n scores -= np.max(scores) # shift by log C to avoid numerical instability\n\n y_mat = np.zeros(shape = (C, N))\n y_mat[y, range(N)] = 1\n\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\n # quantity we need to subtract from each row of scores\n correct_wx = np.multiply(y_mat, scores)\n\n # create a single row of the correct wx_y + log C values for each data point\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\n\n exp_scores = np.exp(scores)\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\n result = np.log(sums_exp)\n\n result -= sums_wy\n\n loss = np.sum(result)\n loss /= num_train\n \n \n # vectorized gradient calculation #\n exp_a_sum = np.sum(exp_a,axis=0)\n\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\n y_mat_corres[y, range(num_train)] = 1\n sum_exp_scores = np.sum(exp_a, axis=0) \n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\n exp_a *= sum_exp_scores\n grad = np.dot(exp_a, X)\n grad -= np.dot(y_mat_corres, X)\n grad /= num_train\n \n\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss, grad","def _train(self, loss):\n config = ConfigParser.ConfigParser()\n config.read(\"config/conf.cfg\")\n\n learning_rate =float(config.get(\"Common Params\", \"learning_rate\"))\n moment = float(config.get(\"Common Params\", \"moment\"))\n opt = tf.train.AdamOptimizer()\n train_step = opt.minimize(loss)\n return train_step\n\n # grads = opt.compute_gradients(self.total_loss)\n\n # apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step)\n\n #return apply_gradient_op","def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\n batch_size=200, verbose=False):\n num_train, dim = X.shape\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\n if self.W is None:\n # lazily initialize W\n self.W = 0.001 * np.random.randn(dim, num_classes)\n\n # Run stochastic gradient descent to optimize W\n loss_history = []\n for it in range(num_iters):\n X_batch = None\n y_batch = None\n\n #########################################################################\n # TODO: #\n # Sample batch_size elements from the training data and their #\n # corresponding labels to use in this round of gradient descent. #\n # Store the data in X_batch and their corresponding labels in #\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\n # and y_batch should have shape (batch_size,) #\n # #\n # Hint: Use np.random.choice to generate indices. Sampling with #\n # replacement is faster than sampling without replacement. #\n #########################################################################\n choices = np.random.choice(num_train, batch_size)\n X_batch = X[choices]\n y_batch = y[choices]\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n # evaluate loss and gradient\n loss, grad = self.loss(X_batch, y_batch, reg)\n loss_history.append(loss)\n\n # perform parameter update\n #########################################################################\n # TODO: #\n # Update the weights using the gradient and the learning rate. #\n #########################################################################\n self.W -= learning_rate * grad\n #########################################################################\n # END OF YOUR CODE #\n #########################################################################\n\n if verbose and it % 100 == 0:\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\n\n return loss_history","def mylinearsvm(lambdat, eta_init, maxiter, X, y):\n d = np.size(X, 1)\n beta_init = np.zeros(d)\n theta_init = np.zeros(d)\n betas, objs = fast_grad(beta_init, theta_init, lambdat, eta_init, maxiter,X=X,y=y)\n return betas, objs","def train(self, features, labels, optimizer, loss_scale=None):\n loss, gradients = self.compute_gradients(\n features,\n labels,\n optimizer,\n loss_scale=loss_scale,\n )\n optimizer.apply_gradients(list(zip(gradients, self.trainable_weights)))\n return loss","def fit(self, X_train, Y_train, X_unlabeled, I_train=None):\n\n logger.info('Fitting semi-supervised classifier ...')\n\n start = time.time()\n\n # Creating a subgraph\n self.subgraph = Subgraph(X_train, Y_train, I_train)\n\n # Finding prototypes\n self._find_prototypes()\n\n # Gather current number of nodes\n current_n_nodes = self.subgraph.n_nodes\n\n for i, feature in enumerate(X_unlabeled):\n node = Node(current_n_nodes + i, 0, feature)\n\n self.subgraph.nodes.append(node)\n\n # Creating a minimum heap\n h = Heap(size=self.subgraph.n_nodes)\n\n for i in range(self.subgraph.n_nodes):\n if self.subgraph.nodes[i].status == c.PROTOTYPE:\n # If yes, it does not have predecessor nodes\n self.subgraph.nodes[i].pred = c.NIL\n\n # Its predicted label is the same as its true label\n self.subgraph.nodes[i].predicted_label = self.subgraph.nodes[i].label\n\n # Its cost equals to zero\n h.cost[i] = 0\n\n # Inserts the node into the heap\n h.insert(i)\n\n else:\n # Its cost equals to maximum possible value\n h.cost[i] = c.FLOAT_MAX\n\n while not h.is_empty():\n # Removes a node\n p = h.remove()\n\n # Appends its index to the ordered list\n self.subgraph.idx_nodes.append(p)\n\n # Gathers its cost\n self.subgraph.nodes[p].cost = h.cost[p]\n\n for q in range(self.subgraph.n_nodes):\n if p != q:\n if h.cost[p] < h.cost[q]:\n if self.pre_computed_distance:\n weight = self.pre_distances[self.subgraph.nodes[p]\n .idx][self.subgraph.nodes[q].idx]\n\n else:\n weight = self.distance_fn(self.subgraph.nodes[p].features, self.subgraph.nodes[q].features)\n\n # The current cost will be the maximum cost between the node's and its weight (arc)\n current_cost = np.maximum(h.cost[p], weight)\n\n if current_cost < h.cost[q]:\n # `q` node has `p` as its predecessor\n self.subgraph.nodes[q].pred = p\n\n # And its predicted label is the same as `p`\n self.subgraph.nodes[q].predicted_label = self.subgraph.nodes[p].predicted_label\n\n # As we may have unlabeled nodes, make sure that `q` label equals to `q` predicted label\n self.subgraph.nodes[q].label = self.subgraph.nodes[q].predicted_label\n\n # Updates the heap `q` node and the current cost\n h.update(q, current_cost)\n\n # The subgraph has been properly trained\n self.subgraph.trained = True\n\n end = time.time()\n\n train_time = end - start\n\n logger.info('Semi-supervised classifier has been fitted.')\n logger.info('Training time: %s seconds.', train_time)","def fit(self, x, y):\n # *** START CODE HERE ***\n num_examples = x.shape[0]\n num_features = x.shape[1]\n iteration = 1\n if self.theta == None:\n self.theta = np.zeros((num_features,))\n while iteration <= self.max_iter:\n h_theta = np.dot(x, self.theta)\n g_theta = self.sigmoid(h_theta)\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\n d_theta = - np.linalg.solve(H, J_prime)\n self.theta += d_theta\n if np.linalg.norm(d_theta, 1) < self.eps:\n break\n if self.verbose:\n print(\"Loss value: \", J_cost)\n iteration += 1\n # *** END CODE HERE ***","def _batch_gradient_descent(self, X, y, lr, epochs):\n\n # Initialize the bias and weights.\n _, n = X.shape\n self.bias = 0\n self.weights = np.random.normal(size=n)\n\n for i in range(epochs):\n # Calculate and sum the gradient delta of each sample\n grad_bias, grad_weights = self._get_gradient(X, y)\n\n # Show the gradient of each epoch.\n grad = (grad_bias + grad_weights.mean()) / 2\n print(\"Epochs %d gradient %.3f\" % (i + 1, grad), flush=True)\n\n # Update the bias and weight by gradient of current epoch\n self.bias += lr * grad_bias\n self.weights += lr * grad_weights","def fit(self, X):","def fit(self, X, y, X_validate, y_validate):\n \n iterate = 800\n \n self.SGD_theta_list = [0]*len(X[0])\n self.SGD_bias = 0\n\n SGD_cost_history = []\n SGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\n temp_X = []\n temp_X.append(X[selection])\n temp_y = []\n temp_y.append(y[selection])\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\n SGD_cost_history.append(SGD_cost)\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\n SGD_validate_cost_history.append(SGD_validate_cost)\n\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), SGD_cost_history)\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss SGD\")\n plt.show()\n \n \n self.BGD_theta_list = [0]*len(X[0])\n self.BGD_bias = 0\n\n BGD_cost_history = []\n BGD_validate_cost_history = []\n\n for i in range(iterate):\n if(i%100==0):\n print(i,\" iterations\")\n selection = random.randint(0, len(X)-1)\n \n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\n\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\n BGD_cost_history.append(BGD_cost)\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\n BGD_validate_cost_history.append(BGD_validate_cost)\n\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\n\n plt.plot(list(range(iterate)), BGD_cost_history)\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\n plt.xlabel(\"Iterations\")\n plt.ylabel(\"Loss BGD\")\n plt.show()\n\n print(\"FINAL_SGD_TRAIN_LOSS\\n\",self.FINAL_SGD_TRAIN_LOSS)\n print(\"FINAL_SGD_VALIDATE_LOSS\\n\",self.FINAL_SGD_VALIDATE_LOSS)\n print(\"FINAL_BGD_TRAIN_LOSS\\n\",self.FINAL_BGD_TRAIN_LOSS)\n print(\"FINAL_BGD_VALIDATE_LOSS\\n\",self.FINAL_BGD_VALIDATE_LOSS)\n\n \n return self"],"string":"[\n \"def train(self,features,y):\\r\\n \\r\\n if self.learn_type == \\\"nn\\\":\\r\\n #generate supervised dataset\\r\\n return(self.learner.train_on_batch(features,y))\\r\\n elif self.learn_type == \\\"linear\\\":\\r\\n grad = 0\\r\\n n = len(features)\\r\\n for i in range(n):\\r\\n #sum over the instances to get an estimate of the gradient\\r\\n print((y[i] - self.learner.activate(features[i])))\\r\\n grad -= (y[i] - self.learner.activate(features[i])) * \\\\\\r\\n self.learner.grad(features[i])\\r\\n grad /= n\\r\\n #update paramter\\r\\n param = np.copy(self.learner.param)\\r\\n self.learner.param = param - self.alpha * grad\\r\\n #print(self.learner.param)\\r\",\n \"def fit(self, x, y):\\n def initiate_theta(dim):\\n self.theta = np.zeros(dim)\\n # print('self.theta initiated is {}'.format(self.theta))\\n \\n def implement_sigmoid(x):\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n z = np.matmul(np.transpose(self.theta), np.transpose(x))\\n return 1/(np.ones(x.shape[0]) + np.exp(-z))\\n \\n def implement_partial_loss(x, y):\\n return -np.matmul(np.transpose(y - implement_sigmoid(x)), x)/x.shape[0]\\n \\n def implement_transposed_hess(x):\\n sigmoid_hadamard = implement_sigmoid(x) * (np.ones(x.shape[0]) - implement_sigmoid(x))\\n hess2 = np.diag(sigmoid_hadamard)\\n hess = np.matmul(hess2,x)\\n hess = np.matmul(np.transpose(x),hess)/x.shape[0]\\n hess_inverse = np.linalg.inv(hess)\\n return hess_inverse\\n \\n def train(x, y):\\n count = 0\\n if self.theta is None:\\n initiate_theta(x.shape[1])\\n while count < self.max_iter:\\n if self.verbose:\\n loss_y1 = np.matmul(np.transpose(y), np.log(implement_sigmoid(x)))\\n loss_y0 = np.matmul(np.transpose(np.ones(x.shape[0]) - y), np.log(np.ones(x.shape[0]) - implement_sigmoid(x)))\\n loss = -(loss_y1 + loss_y0 )/x.shape[0]\\n print('Average empirical loss for step {} is {}'.format(count, loss))\\n delta = np.matmul(implement_transposed_hess(x), implement_partial_loss(x, y))\\n new_theta = self.theta - delta * self.step_size\\n delta_theta = np.linalg.norm(new_theta - self.theta)\\n # print('delta is {}'.format(delta_theta))\\n if delta_theta < self.eps:\\n return new_theta\\n else:\\n self.theta = new_theta\\n count += 1\\n return self.theta\\n \\n return train(x, y)\",\n \"def learn(self):\\n Xt = np.append(np.ones((self.X.shape[0], 1)), self.X, axis=1)\\n Yt = self.Y * 2 - 1\\n\\n w = np.ones(Xt.shape[1]) # avoiding random init, for debugging\\n lw = [[] for k in range(len(w))]\\n \\n for iter in range(self.max_steps):\\n P = Yt * np.dot(Xt, w)\\n M = np.where(P <= 0)[0] # indices of misclassified datapoints\\n\\n if len(M) == 0: \\n self.logger.debug(\\\"Found linearly separable hyperplane!\\\")\\n break\\n\\n if self.is_stochastic:\\n # just pick one randomly from M\\n M = [M[random.randint(0, len(M)-1)]]\\n\\n grad = -1 * np.sum((Yt[M] * Xt[M].T), axis=1) / len(M)\\n\\n if self.reg_constant > 0:\\n grad += self.reg_constant * w\\n \\n eta = self.step_size * 10000 / (10000 + iter)\\n \\n w = w - grad * eta\\n \\n if iter % 100 == 0:\\n for k in range(len(w)):\\n lw[k].append(w[k])\\n \\n if iter % 1000 == 0:\\n self.logger.debug(\\\"Iter %s:\\\\t %f %f %f\\\" %(iter, w[0], w[1], w[2]))\\n \\n self.logger.debug(\\\"Iterations: %s\\\" %(iter))\\n\\n# x_range = range(len(lw[0]))\\n# fig = plt.figure()\\n# ax1 = fig.add_subplot(111) \\n# for j, lwn in enumerate(lw):\\n# if j % 3 >= 2: # plot an arbitrary subset of features\\n# a = w[j]\\n# ax1.plot(x_range, [(x-a) for x in lwn], label=str(j))\\n# \\n# plt.xlabel(\\\"Iteration\\\")\\n# plt.ylabel(\\\"Feature weight\\\")\\n# plt.show()\\n \\n #self.logger.debug(\\\"%s\\\" % np.array2string(w, precision=2, separator=','))\\n \\n self.w = w\",\n \"def train(self, X, y):\",\n \"def fit(x_train,x_test,y_train,y_test):\\n #data=np.loadtxt(\\\"/home/manjunath/iris/iris.csv\\\", comments=None, delimiter=',', usecols=(0,1,2,3,4), converters={4: convert_y }) \\n\\n h=(10,10,10)\\n step_size=0.001\\n tolerence=0.001\\n iteration_max=1000\\n iteration=0\\n #Regularisation param, added to gradients \\n reg=0.01\\n \\n K=np.unique(y_train).shape[0]\\n \\n #x=np.loadtxt(\\\"/home/manjunath/iris/iris.csv\\\", comments=None, delimiter=',', converters=None, usecols=(0,1,2,3))\\n \\n \\n \\\"\\\"\\\"\\n \\n train_mean=np.mean(x_train,axis=0)\\n x_train=x_train-train_mean\\n #std_x = np.sqrt(np.sum(np.square(x_train - train_mean),axis=0)/x_train.shape[1])\\n std_x=np.std(x_train,axis=0)\\n x_train=x_train/std_x\\n \\n x_test=x_test - train_mean\\n x_test=x_test/std_x\\n\\n \\\"\\\"\\\"\\n\\n\\n\\n y_train=y_to_classification_form(y_train,K)\\n y_test=y_to_classification_form(y_test,K)\\n\\n n_samples,n_features=x_train.shape\\n gamma2=np.random.randn(h[0]).reshape(1,h[0])\\n beta2=np.random.randn(h[0]).reshape(1,h[0])\\n gamma3=np.random.randn(h[1]).reshape(1,h[1])\\n beta3=np.random.randn(h[1]).reshape(1,h[1])\\n eps=0.001\\n \\n w1=(np.random.randn(n_features*h[0]).reshape(n_features,h[0]))/np.sqrt(2/(n_features+h[0]))\\n w2=(np.random.randn(h[0]*h[1]).reshape(h[0],h[1]))/np.sqrt(2/(h[0]+h[1]))\\n w3=(np.random.randn(h[1]*h[2]).reshape(h[1],h[2]))/np.sqrt(2/(h[1]+h[2]))\\n \\n dw1_priv=np.zeros(w1.shape)\\n dw2_priv=np.zeros(w2.shape)\\n dw3_priv=np.zeros(w3.shape)\\n \\n #w3=(np.random.randn(h[1]*K).reshape(h[1],K)*0.5)/np.sqrt(2/h[1]+K)\\n #Basically no significance, added bias for completion\\n b1 = np.zeros((1,h[0]))\\n b2 = np.zeros((1,h[1]))\\n b3 = np.zeros((1,K))\\n \\n while iteration<iteration_max :\\n \\n #Calculate scores \\n scores_layer1=np.dot(x_train,w1)+b1 # 125x4,4x10 = 125x10\\n #print(\\\"iteration\\\",iteration, \\\"first layer\\\",np.any(np.isnan(scores_layer1)))\\n #Do not use sigmoid, you will be stuck in long mess of nans and inf and overflows and div by zeros\\n #x2=1/1+np.exp(-scores_layer1) # 150 x 4\\n \\n #Use reLU\\n \\n #x2=np.maximum(0,scores_layer1)\\n bn_x2,bn_cache2=bn.batch_norm_forword(scores_layer1,gamma2,beta2) #125x10\\n #print(\\\"iteration\\\",iteration, \\\"first layer BN\\\",np.any(np.isnan(bn_x2)))\\n #x2=relu.relu_forword(bn_x2.T)\\n x2=relu.relu_forword(bn_x2) #125x10\\n #print(\\\"iteration\\\",iteration, \\\"first layer relu\\\",np.any(np.isnan(x2)))\\n \\n score_layer2=np.dot(x2,w2)+b2 #125x10,10x10=125x10\\n #print(\\\"iteration\\\",iteration, \\\"second layer\\\",np.any(np.isnan(score_layer2)))\\n bn_x3,bn_cache3=bn.batch_norm_forword(score_layer2,gamma3,beta3) #125x10\\n x3=relu.relu_forword(bn_x3) #125x10 \\n \\n final_scores=np.dot(x3,w3)+b3 # 125x10,10x3=125x3\\n \\n #Again, use softmax or sigmoid loss for classification, MSE or distance is for regression only \\n \\n probs=fn.softmax(final_scores) #125x3\\n \\n \\n \\n dscores=fn.cross_enropy_grad_singleclass(probs,y_train) # 125x3\\n #There is possibility of only 1 class for data, so use below, else the implementation will be bit complex \\n #print(x3.shape)\\n dw3=np.dot(x3.T,dscores) # 10x125,125x3=10x3\\n dx3=np.dot(w3,dscores.T) # 10x3,3x125=10x125\\n \\n #dhid2=dx3.T\\n #dhid2[x3<=0]=0\\n \\n dhid2=relu.relu_backword(dx3.T,x3) #125x10\\n #print(\\\"dhid2\\\",dhid2.shape)\\n bn_dhid2,dgamma3,dbeta3=bn.batch_norm_backword(dhid2,bn_cache3) #125x10\\n #dprod = (x2 * (1- x2)) * dx2.T # this is wrong, find out why, we mostly need to multiply with upstream gradient \\n \\n dw2=np.dot(x2.T,bn_dhid2) # 10x125,125x10=10x10\\n dx2=np.dot(w2,dhid2.T) #10x10,10x125=10x125\\n \\n #dhid1=dx2.T\\n #dhid1[x2<=0]=0\\n \\n dhid1=relu.relu_backword(dx2.T,x2) #125x10\\n \\n bn_dx2,dgamma2,dbeta2=bn.batch_norm_backword(dhid1,bn_cache2) #125x10\\n #print(dprod.shape)\\n \\n dw1 = np.dot( x_train.T,bn_dx2) # 125x4,12510=4x10\\n\\n db1=np.sum(b1,axis=0,keepdims=True) \\n db2=np.sum(b2,axis=0,keepdims=True) \\n db3=np.sum(b3,axis=0,keepdims=True)\\n \\n #Regularisation of gradients\\n \\n #Optimisation\\n \\n #dw1 = (dw1+dw1_priv)/2\\n #dw2 = (dw2+dw2_priv)/2\\n #dw3 = (dw3+dw3_priv)/2\\n \\n dw3 += reg*w3\\n dw2 += reg*w2\\n dw1 += reg*w1\\n \\n w1 = w1 - (step_size * dw1)\\n w2 = w2 - (step_size * dw2)\\n w3 = w3 - (step_size * dw3)\\n \\n #print(dw1)\\n #print(dw2)\\n #print(dw3)\\n \\n #dw1_priv=dw1\\n #dw2_priv=dw2\\n #dw3_priv=dw3\\n \\n \\\"\\\"\\\"\\n redundant parameters after batch normalization \\n \\\"\\\"\\\"\\n \\n b1 = b1 - (step_size * db1)\\n b2 = b2 - (step_size * db2)\\n b3 = b3 - (step_size * db3)\\n \\n\\n \\n gamma2= gamma2 - (step_size * dgamma2)\\n beta2 = beta2 - (step_size * dbeta2)\\n gamma3= gamma3 - (step_size * dgamma3)\\n beta3 = beta3 - (step_size * dbeta3)\\n\\n \\n if iteration%10 == 0 :\\n #print(\\\"****iteration:\\\",iteration)\\n #x_test /= 10 \\n \\n s1=np.dot(x_test,w1)\\n #px2=1/1+np.exp(-s1)\\n bn_x2t,bn_cache2t=bn.batch_norm_forword(s1,gamma2,beta2)\\n px2=relu.relu_forword(bn_x2t)\\n \\n s2=np.dot(px2,w2) \\n bn_x3t,bn_cache3t=bn.batch_norm_forword(s2,gamma3,beta3)\\n px3=relu.relu_forword(bn_x3t)\\n \\n out=np.dot(px3,w3)\\n \\n counter=0\\n for y_p,y_a in zip(np.argmax(out,axis=1),y_test):\\n if np.argmax(y_a)==y_p:\\n counter +=1\\n print(\\\"accuracy: \\\", (counter/10000) *100,\\\"%\\\")\\n loss=fn.cross_entropy_loss_singleclass(probs,y_train) # scalar\\n print('Loss',loss/n_samples)\\n \\n dw1_p=np.zeros_like(dw1)\\n dw2_p=np.zeros_like(dw2)\\n dw3_p=np.zeros_like(dw3)\\n \\n print(\\\"dw1\\\",dw1==dw1_p)\\n print(\\\"dw1\\\",dw2==dw2_p)\\n print(\\\"dw1\\\",dw3==dw3_p)\\n \\n dw1_p=dw1\\n dw2_p=dw2\\n dw3_p=dw3\\n \\n #print(\\\"gamma2\\\",gamma2)\\n #print(\\\"beta2\\\",beta2)\\n \\n iteration=iteration+1\\n \\n #print('FInal weights are: ', w1,w2)\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = np.log(label_counts * 1.0 / len(dataset)) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n class_word_counts = np.sum(dataset[start_index:end_index,:-1]) # sum all words of class i \\n denominator = class_word_counts + self.alpha * self.feature_count # Here we add the feature_count as Laplace smoothing\\n \\n for j in range(self.feature_count): # Loop over each feature\\n single_word_count = np.sum(dataset[start_index:end_index,j]) # sum number times word j appears in class i \\n numerator = single_word_count + self.alpha\\n self.p_xi_given_ys[i][j] = log(numerator * 1.0 / denominator) # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def train_gradient_descent(self, X, y, learning_rate=0.01, n_iters=100):\\r\\n # Step 0: Initialize the parameters\\r\\n n_samples, n_features = X.shape\\r\\n self.weights = np.zeros(shape=(n_features,1))\\r\\n self.bias = 0\\r\\n costs = []\\r\\n\\r\\n for i in range(n_iters):\\r\\n # Step 1: Compute a linear combination of the input features and weights\\r\\n y_predict = np.dot(X, self.weights) + self.bias\\r\\n\\r\\n # Step 2: Compute cost over training set\\r\\n cost = (1 / n_samples) * np.sum((y_predict - y)**2)\\r\\n costs.append(cost)\\r\\n\\r\\n if i % 100 == 0:\\r\\n print(f\\\"Cost at iteration {i}: {cost}\\\")\\r\\n\\r\\n # Step 3: Compute the gradients\\r\\n dJ_dw = (2 / n_samples) * np.dot(X.T, (y_predict - y))\\r\\n dJ_db = (2 / n_samples) * np.sum((y_predict - y)) \\r\\n \\r\\n # Step 4: Update the parameters\\r\\n self.weights = self.weights - learning_rate * dJ_dw\\r\\n self.bias = self.bias - learning_rate * dJ_db\\r\\n\\r\\n return self.weights, self.bias, costs\",\n \"def ff_train(\\n self, input_tensor: torch.Tensor, labels: torch.Tensor, theta: float\\n ):\\n with torch.no_grad():\\n states, neg_samples = self.bottom_up(input_tensor, labels)\\n neg_states, _ = self.bottom_up(input_tensor, neg_samples)\\n states = [\\n torch.cat([s, ns], dim=0) for s, ns in zip(states, neg_states)\\n ]\\n signs = torch.cat(\\n [\\n torch.ones(input_tensor.shape[0], device=self.device),\\n -torch.ones(input_tensor.shape[0], device=self.device),\\n ],\\n dim=0,\\n )\\n input_tensor = torch.cat([input_tensor, input_tensor], dim=0)\\n # states have been created, now we can train the network\\n x_proj, accumulated_goodness = self.projector.ff_train(\\n input_tensor, signs, theta\\n )\\n for _ in range(self.time_steps):\\n new_states = []\\n x = x_proj\\n for j, layer in enumerate(self.layers):\\n if j < len(self.layers) - 1:\\n next_state = states[j + 2]\\n else:\\n next_state = self.proj_y(states[j + 2].float())\\n new_states.append(x)\\n x, goodnesses = layer.ff_train(\\n states[j], states[j + 1], next_state, signs, theta\\n )\\n accumulated_goodness[0] += goodnesses[0]\\n accumulated_goodness[1] += goodnesses[1]\\n new_states.append(x)\\n with torch.no_grad():\\n x_ = states[-2][torch.where(signs == -1)]\\n real_y = states[-1][torch.where(signs == 1)]\\n x_[\\n torch.arange(x_.shape[0]), torch.argmax(real_y, dim=1)\\n ] = -1e6\\n y = self.softmax(x_)\\n cumulative_y = torch.cumsum(y, dim=1)\\n neg_samples = torch.argmax(\\n 1.0\\n * (\\n cumulative_y\\n > torch.rand(x_.shape[0], 1).to(self.device)\\n ),\\n dim=1,\\n )\\n neg_samples = torch.functional.F.one_hot(\\n neg_samples, num_classes=self.num_labels\\n )\\n # replace just negative samples\\n next_labels = states[-1].clone()\\n next_labels[torch.where(signs == -1)] = neg_samples\\n new_states.append(next_labels)\\n states = new_states\\n accumulated_goodness[0] /= self.time_steps * len(self.layers) + 1\\n accumulated_goodness[1] /= self.time_steps * len(self.layers) + 1\\n with torch.no_grad():\\n states = [t[: input_tensor.shape[0] // 2] for t in states]\\n return states, accumulated_goodness\",\n \"def trainNN():\\n\\n yTrain = [] # holds y vals of curves/lines\\n trainLabels = [] # holds center labels\\n\\n tryCenters = np.linspace(1, 9, 45)\\n\\n for i in range(len(tryCenters)):\\n x = np.linspace(tryCenters[i]-.2, tryCenters[i]+.2, 18)\\n for j in range(1000):\\n centers = round(random.uniform(tryCenters[i]-.05,\\n tryCenters[i]+.05), 1)\\n y = gauss_func(x, .05, centers, 1)\\n yTrain.append(y)\\n trainLabels.append(1)\\n\\n y = gauss_func(x, .05,\\n round(random.uniform(tryCenters[i]-.3,\\n tryCenters[i]-.17), 1), 1)\\n yTrain.append(y)\\n trainLabels.append(0)\\n\\n y = gauss_func(x, .05,\\n round(random.uniform(tryCenters[i]+.17,\\n tryCenters[i]+.3), 1), 1)\\n yTrain.append(y)\\n trainLabels.append(0)\\n\\n y = 0*x\\n yTrain.append(y)\\n trainLabels.append(0)\\n clf = MLPClassifier(solver='lbfgs')\\n clf.fit(yTrain, trainLabels)\\n return clf\",\n \"def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n if self.W is None:\\n self.W = np.random.randn(dim, num_classes) * 0.001\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n for it in xrange(num_iters):\\n batch_ind = np.random.choice(X.shape[0],batch_size, replace=True)\\n X_batch = X[batch_ind]\\n y_batch = y[batch_ind]\\n\\n # Step One: Implement Stochastic\\n #########################################################################\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n\\n # Step Two: Implement Gradient\\n # Simply call self.loss (which calls svm_loss_vectorized) to evaluate loss and gradient\\n loss, dW = self.loss(X_batch,y_batch,reg)\\n loss_history.append(loss)\\n\\n # Step Three: Implement Descent\\n # Simply update the weights using the gradient and the learning rate. #\\n self.W -= dW*learning_rate\\n\\n if verbose and it % 100 == 0:\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def train(self, X, y):\\n m = X.shape[0]\\n D = np.empty(m)\\n D.fill(1/(m*1.0))\\n\\n hs = 0\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n eps = 0\\n\\n for j in range(m): \\n if (y[j]*(1.0) != self.h[t].predict(X)[j]):\\n eps+=D[j]\\n\\n self.w[t] =0.5*math.log((1/eps)-1)\\n\\n Dtmp = []\\n for j in range(m):\\n Dtmp.append(D[j]*math.exp(-1*self.w[t]*y[j]*(self.h[t].predict(X)[j])))\\n\\n Dtmp = np.array(Dtmp) \\n s = np.sum(Dtmp)\\n\\n for i in range(m):\\n D[i] = (D[i]*math.exp(-1*self.w[t]*y[i]*self.h[t].predict(X)[i]))/s\",\n \"def _stochastic_gradient_descent(self, X, y, lr, epochs, sample_rate):\\n\\n # Initialize the bias and weights.\\n m, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n n_sample = int(m * sample_rate)\\n for i in range(epochs):\\n for idx in choice(range(m), n_sample, replace=False):\\n # Calculate the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X[idx], y[idx])\\n\\n # Update the bias and weight by gradient of current sample\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\\n\\n # Show the gradient of each epoch.\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\",\n \"def train(self, dataset): \\n dataset = dataset[dataset[:,-1].argsort()] # Sort the dataset by classes.\\n #print dataset\\n \\n ########\\n # Compute p(y=1) for all ys.\\n ########\\n label_counts = np.bincount(dataset[:,-1]) # Get the number of occurrences of each class, sorted. \\n self.p_ys = label_counts * 1.0 / len(dataset) # Compute probs. \\n \\n ########\\n # Compute p(x|y) for all x,y.\\n ########\\n self.feature_count = len(dataset[0]) - 1 \\n self.class_count = len(label_counts)\\n \\n self.p_xi_given_ys = np.zeros((self.class_count, self.feature_count)) # Initialize matrix\\n start_index = 0\\n for i in range(self.class_count): # Loop over each class \\n end_index = start_index + label_counts[i] # end of this class index \\n denominator = label_counts[i] + 2.0 * self.alpha\\n \\n for j in range(self.feature_count): # Loop over each feature\\n numerator = np.sum(dataset[start_index:end_index,j]) + self.alpha # Sum number of times word j = 1 in class i\\n self.p_xi_given_ys[i][j] = numerator * 1.0 / denominator # Compute p(xi|y)\\n \\n start_index = end_index\",\n \"def fit(self, X, y, alpha, n_epochs):\\n y = self.__one_hot(y)\\n \\n # perform training epochs\\n for i in range(n_epochs):\\n print(\\\"Epoch\\\", i)\\n # stochastic gradient descent\\n for j in range(len(X)):\\n self.__backpropagation(X[j], y[j], alpha)\",\n \"def train_SGD():\\n\\n #load the data\\n path_dataset = \\\"data/data_train.csv\\\"\\n train = load_data(path_dataset)\\n\\n \\\"\\\"\\\"matrix factorization by SGD.\\\"\\\"\\\"\\n\\n #define parameters (optimal parameters from cross-validation)\\n gamma = 0.12\\n num_features = 25 \\n lambda_user = 0.02 \\n lambda_item = 0.24\\n num_epochs = 100\\n\\n #run the factorization\\n user_features, item_features = matrix_factorization_SGD(train, num_features, lambda_user, lambda_item, num_epochs, gamma)\\n\\n #save item_features_SGD\\n file = open(\\\"data/item_features_SGD.obj\\\",\\\"wb\\\")\\n pickle.dump(item_features,file)\\n file.close()\\n\\n #save user_features_SGD\\n file = open(\\\"data/user_features_SGD.obj\\\",\\\"wb\\\")\\n pickle.dump(user_features,file)\\n file.close()\",\n \"def train(net):\\n\\n # Set SGD hyperparameters\\n n_iter = 200 # number of iterations of SGD\\n learning_rate = 1e-3 # learning rate for SGD\\n momentum = .99 # momentum parameter for SGD\\n batch_size = 100 # number of data points in each mini-batch\\n\\n # Initialize binary cross-entropy loss function\\n loss_fn = nn.BCELoss()\\n\\n # Initialize SGD optimizer with momentum\\n optimizer = optim.SGD(net.parameters(), lr=learning_rate, momentum=momentum)\\n\\n # Placeholder to save loss at each iteration\\n track_loss = []\\n\\n # Loop over iterations\\n for i in range(n_iter):\\n\\n # Sample minibatch of oriented grating stimuli\\n stimuli, tilt = sample_stimuli(batch_size)\\n\\n # Evaluate loss and update network weights\\n out = net(stimuli) # predicted probability of tilt right\\n loss = loss_fn(out, tilt) # evaluate loss\\n optimizer.zero_grad() # clear gradients\\n loss.backward() # compute gradients\\n optimizer.step() # update weights\\n \\n # Keep track of loss at each iteration\\n track_loss.append(loss.item())\\n\\n # Track progress\\n if (i + 1) % (n_iter / 10) == 0:\\n print('iteration %i | loss: %.3f | percent correct: %.2f%%' % (i + 1, loss.item(), 100 * pcorrect(out, tilt)))\\n \\n # Plot loss\\n plt.plot(track_loss)\\n plt.xlabel('iterations of SGD')\\n plt.ylabel('binary cross-entropy loss')\\n plt.xlim([0, None])\\n plt.ylim([0, None])\\n plt.show()\",\n \"def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\\\"Delta\\\"):\\n rem = int(np.ceil(len(X[0])/batch_size))\\n for epoch in range(num_epochs):\\n art = 0;\\n for sample in range(rem):\\n end = art + batch_size\\n\\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\\n sampleX = X[:, art : end]\\n sampleY = y[:, art : end]\\n #print (sampleX)\\n\\n # Get the prediction\\n results = self.predict(sampleX)\\n art += batch_size\\n\\n if learning == \\\"Delta\\\" or learning == \\\"delta\\\":\\n # Calculate e\\n e = np.subtract(sampleY, results)\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(e, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\\n \\n elif learning == \\\"Filtered\\\" or learning == \\\"filtered\\\":\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(sampleY, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Multiply the old weights by some scalar gamma\\n gw = np.multiply(1 - gamma, self.weights)\\n\\n self.weights = np.add(gw, aep)\\n\\n elif learning == \\\"Unsupervised_hebb\\\" or learning == \\\"unsupervised_hebb\\\":\\n # Add a row of one's to the top of the input matrix\\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(results, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\",\n \"def train(self, X, y, learning_rate=1e-3, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n\\n self.init_weights(dims=[np.max(y) + 1, X.shape[1]])\\t# initializes the weights of self.W\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n\\n for it in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in \\n # gradient descent. After sampling,\\n # - X_batch should have shape: (dim, batch_size)\\n # - y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations\\n # in the dataset. Use np.random.choice. It's okay to sample with\\n # replacement.\\n # ================================================================ #\\n mask = np.random.choice(num_train, batch_size, replace=True)\\n \\n X_batch = X[mask] # (dim, batch_size)\\n y_batch = y[mask] # (batch_size,)\\n \\n pass\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n # evaluate loss and gradient\\n loss, grad = self.fast_loss_and_grad(X_batch, y_batch)\\n loss_history.append(loss)\\n\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Update the parameters, self.W, with a gradient step \\n # ================================================================ #\\n pass\\n \\n self.W = self.W - learning_rate*grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n if verbose and it % 100 == 0:\\n print('iteration {} / {}: loss {}'.format(it, num_iters, loss))\\n\\n return loss_history\",\n \"def trainModel( self, featureTrain, classTrain):\",\n \"def train(features, targets, weights, bias):\\n # see gradient_descent for explanation\\n epochs = 100\\n learning_rate = 0.1\\n\\n picture_nb = 2\\n\\n # Print current accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n for epoch in range(epochs):\\n if epoch % 10 == 0:\\n # get normalized scores\\n predictions = activation(pre_activation(features, weights, bias))\\n # compare with targets to see how bad our algorithm is\\n print(\\\"Cost = %s\\\" % cost(predictions, targets))\\n # Replot graph. Check in create_dataset for explanation of parameters\\n if picture_nb == 2:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='red')\\n elif picture_nb == 11:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='green')\\n else:\\n plt.plot(features[:, 0], (weights[0] * features[:, 0] + bias) / -weights[1], color='orange')\\n picture_nb+=1\\n\\n # Initialize gradients\\n # weights_gradients is 2D array with 2 values\\n weights_gradients = np.zeros(weights.shape)\\n bias_gradient = 0\\n # Go through each row\\n for feature, target in zip(features, targets):\\n # Compute prediction\\n z = pre_activation(feature, weights, bias)\\n # Get normalized score\\n y = activation(z)\\n # Update gradients based on formulas established before. Look at gradient_descent to understand what we\\n # are doing. Also, the formulas are below, just before the call of the function train.\\n weights_gradients += (y - target) * derivative_activation(z) * feature\\n # no multiplication of feature because it does not depend on some coordinates.\\n bias_gradient += (y - target) * derivative_activation(z)\\n\\n # Update variables. These are the lines that result the cost to get reduced.\\n weights = weights - learning_rate * weights_gradients\\n bias = bias - learning_rate * bias_gradient\\n\\n # Print final accuracy. How many people have been classified as sick/healthy correctly?\\n predictions = predict(features, weights, bias)\\n print(\\\"Accuracy: \\\", np.mean(predictions == targets))\\n\\n plt.scatter(features[:, 0], features[:, 1], s=40, c=targets, cmap=plt.cm.Spectral)\\n plt.savefig(\\\"DataPointsLineEvolution.png\\\")\\n # legend for understanding\\n plt.legend(['Original division', 'New division', 'New division', 'New division', 'New division', 'New division',\\n 'New division', 'New division', 'New division', 'Final division'], loc='upper left')\\n # save picture of data points drawn.\\n plt.savefig(\\\"DataPointsLineEvolutionLegend.png\\\")\",\n \"def _gradient_descent(self, X, y, epochs, learning_rate, batch_size):\\n num_feats = X.shape[1]\\n num_samples = X.shape[0]\\n\\n y = y.reshape(num_samples, 1)\\n W = np.random.rand(num_feats, 1)\\n training_loss_epochs = []\\n\\n for ix in range(epochs):\\n shuffled_ix = (np.arange(0, len(X)))\\n np.random.shuffle(shuffled_ix)\\n X = X[shuffled_ix, :]\\n y = y[shuffled_ix, :]\\n\\n for batch_ix in np.arange(0, X.shape[0], batch_size):\\n dW = self._compute_gradient(W, X[batch_ix:batch_ix + batch_size], y[batch_ix:batch_ix + batch_size])\\n W -= learning_rate * dW\\n\\n if ix % 10 == 0:\\n y_pred = np.dot(X, W)\\n training_loss = self.mse(y, y_pred)\\n print('epoch {0} : training loss {1}'.format(ix, training_loss))\\n training_loss_epochs.append(training_loss[0])\\n\\n self.weights = W\\n self.training_loss = training_loss_epochs\\n return None\",\n \"def ff_train(\\n self, input_tensor: torch.Tensor, signs: torch.Tensor, theta: float\\n ):\\n # upgrade optimizer for positive goodness\\n y = self(input_tensor.detach())\\n y_pos = y[torch.where(signs == 1)]\\n y_neg = y[torch.where(signs == -1)]\\n # y_pos = self(input_tensor.detach()[torch.where(signs == 1)])\\n loss_pos, cumulated_logits_pos = self.loss_fn(y_pos, theta, sign=1)\\n # self.optimizer.zero_grad()\\n # loss_pos.backward()\\n # print(loss_pos.item())\\n # self.optimizer.step()\\n # y_neg = self(input_tensor.detach()[torch.where(signs == -1)])\\n loss_neg, cumulated_logits_neg = self.loss_fn(y_neg, theta, sign=-1)\\n self.optimizer.zero_grad()\\n loss = loss_pos + loss_neg\\n loss.backward()\\n self.optimizer.step()\\n separation = [cumulated_logits_pos, cumulated_logits_neg]\\n y = torch.zeros(\\n input_tensor.shape[0], *y_pos.shape[1:], device=input_tensor.device\\n )\\n y[torch.where(signs == 1)] = y_pos\\n y[torch.where(signs == -1)] = y_neg\\n return y.detach(), separation\",\n \"def train(self, F, Y_batch):\\n H_init = np.array(Y_batch.numpy(), copy=True)\\n H_init[H_init.sum(1) > 1] *= 0\\n H,Z= solve_H(torch.FloatTensor(H_init), F,self.dist,Y=Y_batch.numpy(),iters=self.solve_H_iters, return_Z=True)\\n Z_aug = Variable(Z[None].repeat(F.size()[0], 1,1))\\n tv_F = Variable(F, requires_grad=True)\\n F_aug = tv_F[:,None].repeat(1,Z.size()[0],1)\\n d = torch.pow(Z_aug- F_aug,2).sum(-1)[...,0] # (N, K) distances to clusters\\n ##\\n tv_Y = Variable(torch.LongTensor(H.numpy().argmax(1)))\\n py_x = self.lsoftmax(-d)\\n loss = self.nll(py_x, tv_Y)\\n ##\\n loss.backward()\\n G = tv_F.grad.data \\n train_pred = H.numpy().argmax(1)\\n return loss.data[0], G, train_pred\",\n \"def trainSVM(dataSet, epochs, C, rho):\\n \\n D = len(dataSet[0][0]);\\n w = np.zeros(D);\\n t = 0;\\n \\n # run for some epochs, over every training point in random order on each epoch \\n for epoch in range(epochs): \\n\\n random.shuffle(dataSet); \\n for [x, y] in dataSet:\\n \\n # compute learning rate for this itr\\n r = rho/(1 + rho*t/C); \\n \\n # compute gradient on single example\\n if y*np.dot(w, x) <= 1:\\n grad = w - C*y*x;\\n else:\\n grad = w;\\n \\n # update weight vector\\n w = w - r*grad;\\n \\n t = t + 1;\\n \\n return w;\",\n \"def train(self, loss_function='logistic',\\n lr=0.1, decay=0.5, max_iters=3000, batch_size=128, **kwargs):\\n return super(LogisticRegression, self).train('sgd', loss_function,\\n lr=lr,\\n decay=decay, max_iters=max_iters,\\n batch_size=batch_size, **kwargs)\",\n \"def gradient_descent(self, x, y):\\n # Initialize weights vector\\n self.weights = np.zeros(len(x[0]))\\n\\n # Storing number of training example in a variable \\n n = len(x)\\n\\n # Initiate variables to keep track of the current and smallest loss recorded\\n lowest_loss = sys.float_info.max\\n current_loss = sys.float_info.max\\n\\n # Initiate variables to keep track of step sizes\\n norm = sys.float_info.max\\n smallest_norm = sys.float_info.max\\n\\n # Initiate list variable that stores all previous weights\\n prev_weights = []\\n\\n # Initiate list that stores all the errors. \\n errors = []\\n \\n # Variable to keep track of the number of iterations that returns a bigger loss than current loss\\n k_loss_iteration = 1\\n\\n # Learning loop\\n for i in range(self.max_iter):\\n\\n # Append current weights\\n prev_weights.append(np.array(self.weights))\\n \\n # Minimizing Loss Function Error by adjusting weights using Gradient Descent\\n self.weights += self.learning_rate * (sum([x[i] * (y[i] - self.logistic_function(self.weights.dot(x[i]))) for i in range(n)]) - 2 * self.l2 * self.weights)\\n\\n # Compute the error of the Cost Function and store it in a list\\n current_loss = self.cost(x,y)\\n\\n if len(errors) > 1 and current_loss > errors[-1]:\\n k_loss_iteration += 1\\n else: \\n k_loss_iteration = 1\\n\\n errors.append(current_loss)\\n \\n # Track smallest loss\\n if current_loss < lowest_loss:\\n lowest_loss = current_loss\\n\\n # Compute the L2 Norm of the difference between current weights and previous weights\\n norm = np.linalg.norm(self.weights - prev_weights[-1])\\n\\n # Track smallest step size and set it as error threshold\\n if norm < smallest_norm:\\n smallest_norm = norm\\n\\n # If this L2 norm is smaller than the error_threshold it means that it converged, hence we can break. In other words, repeat until the step size is too small\\n if self.error_threshold != None and norm < self.error_threshold:\\n print(\\\"Converged after {} iterations!\\\".format(i))\\n break\\n\\n # stop if error hasn't gone down in k iterations\\n if k_loss_iteration >= 10:\\n print(k_loss_iteration + \\\" iterations of loss not decreasing on {}th itertion.\\\".format(i))\\n break\\n\\n # Log final weights\\n print(\\\"Final norm: \\\" + str(norm) + \\\"\\\\nSmallest step size recorded: \\\" + str(smallest_norm) + \\\"\\\\nFinal error: \\\" + str(current_loss) + \\\"\\\\nLowest error recorded: \\\" + str(lowest_loss) + \\\"\\\\nNumber of epochs: \\\" + str(len(errors)) + \\\"\\\\nFinal weights: \\\" + str(self.weights))\",\n \"def train_model(X_train, y_train):\\n rgs = linear_model.Lasso(alpha=0.1)\\n rgs.fit(X_train, y_train)\\n return rgs\",\n \"def train( self, trainingData, trainingLabels, validationData, validationLabels ):\\n\\n self.features = trainingData[0].keys() # could be useful later\\n # DO NOT ZERO OUT YOUR WEIGHTS BEFORE STARTING TRAINING, OR\\n # THE AUTOGRADER WILL LIKELY DEDUCT POINTS.\\n for iteration in range(self.max_iterations):\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n print (\\\"Starting iteration \\\", iteration, \\\"...\\\")\\n for i in range(len(trainingData)):#training data\\n max = -10000000\\n for j in range(len(self.weights)):\\n prod = np.dot(self.weights[j], trainingData[i]) #este sería x0 (en la primera vuelta) (xj)\\n if (prod > max):\\n max=prod #en max guardamos la distancia a la instancia que más cerca está de la que estamos recorriendo\\n indclase=j #guardas el índice de la clase a la que predices que pertenece\\n\\n if(indclase != trainingLabels[i]):\\n # recalcular pesos\\n self.weights[trainingLabels[i]].__radd__(trainingData[i]) #honek jarraian egiten du gehiketa pisu guztientzat\\n #pdb.set_trace() # esto es un break point para que puedas comprobar el formato de los datos\\n self.weights[indclase].__sub__(trainingData[i]) #honek jarraian egiten du kenketa pisu guztientzat\\n\\n\\n\\n\\n\\n ########################################################################################\\n # 1. i es el indice de un ejemplo (un item, f(x) de un ejemplo) del conjunto de entrenamiento.\\n # 2. Asi pues, en cada vuelta de este loop se trata un solo ejemplo\\n # por cada ejemplo calculareis el producto punto (dotProduct) w*item\\n # NOTAS: Recordad que cada ejemplo viene representado por varios rasgos (o features), es decir, es un vector de rasgos, tantos como nos marca el atributo self.features.\\n # Asi cada ejemplo es de dimension 1 filas y self.features).\\n # La dimension del vector w tambien es self.features, es decir, habra tantos pesos en w_rasgo dentro de w como rasgos haya en cada item de ejemplo\\n # Recordad tambien que es una clasificacion multiclase en este caso. Hay tantas clases como nos marca el atributo self.legalLabels\\n #########################################################################################\",\n \"def train_classifier(train_data, dev_data, num_iterations, learning_rate, params):\\n\\n for I in xrange(num_iterations):\\n cum_loss = 0.0 # total loss in this iteration.\\n random.shuffle(train_data)\\n for label, features in train_data:\\n x = feats_to_vec(features) # convert features to a vector.\\n y = utils.L2I[label] # convert the label to number if needed.\\n loss, grads = ll.loss_and_gradients(x,y,params)\\n cum_loss += loss\\n # YOUR CODE HERE\\n # update the parameters according to the gradients\\n # and the learning rate.\\n params[0] -= learning_rate * grads[0]\\n params[1] -= learning_rate * grads[1]\\n train_loss = cum_loss / len(train_data)\\n train_accuracy = accuracy_on_dataset(train_data, params)\\n dev_accuracy = accuracy_on_dataset(dev_data, params)\\n print I, train_loss, train_accuracy, dev_accuracy\\n return params\",\n \"def train_LR(self, X, y, eta=1e-3, batch_size=1, num_iters=1000) :\\n loss_history = []\\n N,d = X.shape\\n for t in np.arange(num_iters):\\n X_batch = None\\n y_batch = None\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Sample batch_size elements from the training data for use in gradient descent. \\n # After sampling, X_batch should have shape: (batch_size,1), y_batch should have shape: (batch_size,)\\n # The indices should be randomly generated to reduce correlations in the dataset. \\n # Use np.random.choice. It is better to user WITHOUT replacement.\\n # ================================================================ #\\n \\n # sample indices without replacement\\n batch_idx = np.random.choice(N, batch_size, replace = False)\\n X_batch = X[batch_idx]\\n y_batch = y[batch_idx]\\n \\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss = 0.0\\n grad = np.zeros_like(self.w)\\n # ================================================================ #\\n # YOUR CODE HERE: \\n # evaluate loss and gradient for batch data\\n # save loss as loss and gradient as grad\\n # update the weights self.w\\n # ================================================================ #\\n \\n # compute the loss and gradient\\n # loss_and_grad will take responsible for these\\n \\n loss, grad = self.loss_and_grad(X_batch, y_batch)\\n \\n self.w = self.w - eta * grad\\n \\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n loss_history.append(loss)\\n return loss_history, self.w\",\n \"def learn(self, Xtrain, ytrain):\",\n \"def nnRegression(data):\",\n \"def fit(self, X, Y, lrate=0.01, training_steps=100, coeff_reg=0.1):#, batch_size=1):\\n num_instances = len(X)\\n num_features = len(X[0])\\n\\n x = T.matrix(\\\"x\\\")\\n y = T.vector(\\\"y\\\")\\n w = theano.shared(np.random.random((num_features,)), name=\\\"w\\\")\\n b = theano.shared(0., name=\\\"b\\\")\\n\\n #p = 1 / (1 + T.exp(-(T.dot(x, w) + b)))\\n p = (1 + T.tanh(-(T.dot(x, w) + b))) / 2\\n cost = ((p - y) ** 2).sum() + coeff_reg * (w ** 2).sum()\\n gw, gb = T.grad(cost, [w, b])\\n\\n train = theano.function(\\n inputs=[x,y],\\n outputs=[cost],\\n updates=((w, w - lrate * gw), (b, b - lrate * gb)),\\n allow_input_downcast=True)\\n\\n cst = [0] * training_steps\\n #num_batches = num_instances // batch_size\\n for i in xrange(training_steps):\\n \\\"\\\"\\\"\\n for j in xrange(num_batches):\\n #lidx = j*batch_size\\n #uidx = min(num_instances, lidx+batch_size)\\n #err = train(X[lidx:uidx], Y[lidx:uidx])\\n err = train(X[j:(j+1)], Y[j:(j+1)])\\n \\\"\\\"\\\"\\n err = train(X, Y)\\n cst[i] = sum(err)\\n print \\\"%d\\\\t%f\\\" % (i, cst[i])\\n\\n plt.plot(cst)\\n #plt.show()\\n plt.savefig('bgd.png')\\n\\n self.w = w.get_value()\\n self.b = b.get_value()\",\n \"def fit(self, X, Y):\\n X = X.toarray() # convert X to ndarray\\n Y = Y.to_numpy() # convert Y to numpy array\\n Y[Y == 0] = -1 # convert all zeros to -1, the SVM works with -1 and 1 values\\n\\n self.w = np.zeros(X.shape[1])\\n self.b = 0\\n\\n for iter in range(self.iterations):\\n X, Y = shuffle(X, Y)\\n for idx, x_i in enumerate(X):\\n dw, db = self.compute_gradients(x_i, Y[idx])\\n self.update_gradients(dw, db)\",\n \"def train(train_ds):\\n rng = random.PRNGKey(0)\\n\\n # initialise the model\\n py, params = GPModel.init(rng, train_ds['index_points'])\\n model = nn.Model(GPModel, params)\\n\\n # utility functions for packing and unpacking param dicts\\n par_from_array, array_from_par = build_par_pack_and_unpack(model)\\n\\n @jax.jit\\n def loss_fun(model: GPModel, params: dict) -> float:\\n \\\"\\\"\\\" This is clumsier than the usual FLAX loss_fn. \\\"\\\"\\\"\\n py = model.module.call(params, train_ds['index_points'])\\n return -py.log_prob(train_ds['y'])\\n\\n # wrap loss fun for scipy.optimize\\n def wrapped_loss_fun(arr):\\n params = par_from_array(arr)\\n return loss_fun(model, params)\\n\\n @jax.jit\\n def loss_and_grads(x):\\n return jax.value_and_grad(wrapped_loss_fun)(x)\\n\\n res = oscipy.optimize.minimize(\\n loss_and_grads,\\n x0=array_from_par(params),\\n jac=True,\\n method='BFGS')\\n\\n logging.info('Optimisation message: {}'.format(res.message))\\n\\n trained_model = model.replace(params=par_from_array(res.x))\\n return trained_model\",\n \"def train_step(self, batch):\\n user, pos, neg = batch\\n with tf.GradientTape() as t:\\n\\n # Clean Inference\\n xu_pos, gamma_u, gamma_pos, emb_pos_feature, theta_u, beta_pos = \\\\\\n self(inputs=(user, pos), training=True)\\n xu_neg, _, gamma_neg, _, _, beta_neg = self(inputs=(user, neg), training=True)\\n\\n result = tf.clip_by_value(xu_pos - xu_neg, -80.0, 1e8)\\n loss = tf.reduce_sum(tf.nn.softplus(-result))\\n\\n # Regularization Component\\n reg_loss = self.reg * tf.reduce_sum([tf.nn.l2_loss(gamma_u),\\n tf.nn.l2_loss(gamma_pos),\\n tf.nn.l2_loss(gamma_neg),\\n tf.nn.l2_loss(theta_u)]) * 2 \\\\\\n + self.reg * tf.nn.l2_loss(beta_pos) * 2 \\\\\\n + self.reg * tf.nn.l2_loss(beta_neg) * 2 / 10 \\\\\\n + self.reg * tf.reduce_sum([tf.nn.l2_loss(self.E), tf.nn.l2_loss(self.Bp)]) * 2\\n\\n # Loss to be optimized\\n loss += reg_loss\\n\\n params = [\\n self.Bi,\\n self.Gu,\\n self.Gi,\\n self.Tu,\\n self.E,\\n self.Bp\\n ]\\n\\n grads = t.gradient(loss, params)\\n self.optimizer.apply_gradients(zip(grads, params))\\n\\n return loss.numpy()\",\n \"def train(self, X, Y, init='zeros', stepsize=.01, tolerance=1e-4, max_steps=5000):\\n\\t\\tif self.wts[0].shape[1] - 1 != len(X[0]):\\n\\t\\t\\traise ValueError('NNetClassify.__init__: sizes[0] must == len(X) (number of features)')\\n\\n\\t\\tif len(np.unique(Y)) != self.wts[-1].shape[0]:\\n\\t\\t\\traise ValueError('NNetClassify.__init__: sizes[-1] must == the number of classes in Y')\\n\\n\\t\\tself.classes = self.classes if self.classes else np.unique(Y)\\n\\n\\t\\t# convert Y to 1-of-K format\\n\\t\\tY_tr_k = to_1_of_k(Y)\\n\\n\\t\\tn,d = mat(X).shape\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# d = dim of data, n = number of data points\\n\\t\\tnc = len(self.classes)\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# number of classes\\n\\t\\tL = len(self.wts) \\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# get number of layers\\n\\n\\t\\t# define desired activation function and it's derivative (for training)\\n\\t\\tsig,d_sig, = self.sig, self.d_sig\\n\\t\\tsig_0,d_sig_0 = self.sig_0, self.d_sig_0\\n\\n\\t\\t# outer loop of stochastic gradient descent\\n\\t\\titer = 1\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# iteration number\\n\\t\\tdone = 0\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# end of loop flag\\n\\n\\t\\tsurr = np.zeros((1, max_steps + 1)).ravel()\\t\\t\\t\\t\\t\\t\\t# surrogate loss values\\n\\t\\terr = np.zeros((1, max_steps + 1)).ravel()\\t\\t\\t\\t\\t\\t\\t# misclassification rate values\\n\\n\\t\\twhile not done:\\n\\t\\t\\tstep_i = stepsize / iter\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# step size evolution; classic 1/t decrease\\n\\t\\t\\t\\n\\t\\t\\t# stochastic gradient update (one pass)\\n\\t\\t\\tfor i in range(n):\\n\\t\\t\\t\\tA,Z = self.__responses(self.wts, X[i,:], sig, sig_0)\\t\\t# compute all layers' responses, then backdrop\\n\\t\\t\\t\\tdelta = (Z[L] - Y_tr_k[i,:]) * arr(d_sig_0(Z[L]))\\t\\t\\t# take derivative of output layer\\n\\n\\t\\t\\t\\tfor l in range(L - 1, -1, -1):\\n\\t\\t\\t\\t\\tgrad = mat(delta).T * mat(Z[l])\\t\\t\\t\\t\\t\\t\\t# compute gradient on current layer wts\\n\\t\\t\\t\\t\\tdelta = np.multiply(delta.dot(self.wts[l]), d_sig(Z[l]))# propagate gradient downards\\n\\t\\t\\t\\t\\tdelta = delta[:,1:]\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t# discard constant feature\\n\\t\\t\\t\\t\\tself.wts[l] = self.wts[l] - step_i * grad\\t\\t\\t\\t# take gradient step on current layer wts\\n\\n\\t\\t\\terr[iter] = self.err_k(X, Y_tr_k)\\t\\t\\t\\t\\t\\t\\t\\t# error rate (classification)\\n\\t\\t\\tsurr[iter] = self.mse_k(X, Y_tr_k)\\t\\t\\t\\t\\t\\t\\t\\t# surrogate (mse on output)\\n\\n\\t\\t\\tprint('surr[iter]')\\n\\t\\t\\tprint(surr[iter])\\n\\t\\t\\tprint('iter')\\n\\t\\t\\tprint(iter)\\n\\n\\t\\t\\t# check if finished\\n\\t\\t\\tdone = (iter > 1) and (np.abs(surr[iter] - surr[iter - 1]) < tolerance) or iter >= max_steps\\n\\t\\t\\titer += 1\",\n \"def train(self, target):\\n\\n n_it = 0\\n\\n # print(\\\"\\\\nsomme_erreure maximale (calcul initial) = \\\" + str(somme_erreur_av)+'\\\\n')\\n\\n while self.training:\\n\\n L_erreures_normalisees_base_training = []\\n L_erreures_normalisees_base_test = []\\n\\n # on entraine le reseau en passant 100 fois la base d'exemple\\n for k in range(100):\\n\\n # calcul de l'erreur cummulée sur toute la base d'exemple\\n somme_erreur = [0, 0] # pour le gradient\\n somme_erreur_carré = [0, 0]\\n somme_erreur_carré_test = [0, 0]\\n\\n for i in range(len(sample_position)):\\n command = self.network.runNN(\\n sample_position[i]) # propage erreur et calcule la vitesse des roues instant t\\n erreur = [(command[0] - sample_command[i][0]), (command[1] - sample_command[i][1])]\\n somme_erreur[0] += erreur[0]\\n somme_erreur[1] += erreur[1]\\n\\n somme_erreur_carré[0] += erreur[0] ** 2\\n somme_erreur_carré[1] += erreur[1] ** 2\\n\\n # self.network.backPropagate(erreur, 0.0001, 0) ne marche pas bien\\n\\n # ajout de l'erreure au carré normaliséé par la taille de la base d'apprentissage et moyenné sur les 2 roues\\n L_erreures_normalisees_base_training.append((somme_erreur_carré[0] / (1 * len(sample_position)) +\\n somme_erreur_carré[1] / (1 * len(sample_position))) / 2)\\n\\n # print(\\\"A l'itération \\\" + str(n_it) + \\\", somme_erreur_carré = \\\"+str(somme_erreur_carré))\\n\\n grad = [0, 0]\\n grad[0] = somme_erreur[0] / (1 * len(sample_position)) # erreur moyenne\\n grad[1] = somme_erreur[1] / (1 * len(sample_position))\\n\\n self.network.backPropagate(grad, 0.005, 0)\\n # grad, pas d'app, moment : permet de lisser la trajectoire\\n\\n n_it += 1\\n\\n # Fin de l'itération pour la base d'apprentissage, début pour la base de test\\n for i in range(len(test_position)):\\n command = self.network.runNN(\\n test_position[i]) # propage erreur et calcule la vitesse des roues instant t\\n erreur_test = [(command[0] - test_command[i][0]), (command[1] - test_command[i][1])]\\n somme_erreur_carré_test[0] += erreur_test[0] ** 2\\n somme_erreur_carré_test[1] += erreur_test[1] ** 2\\n\\n L_erreures_normalisees_base_test.append((somme_erreur_carré_test[0] / (1 * len(test_position)) +\\n somme_erreur_carré_test[1] / (1 * len(test_position))) / 2)\\n\\n # Tracé des courbes\\n pl.clf()\\n X = [i + 1 for i in range(len(L_erreures_normalisees_base_training))]\\n # X2 = [i + 1 for i in range(len(L_erreures_normalisees_base_training))]\\n\\n pl.plot(X, L_erreures_normalisees_base_training, 'r+')\\n pl.plot(X, L_erreures_normalisees_base_test, 'bo')\\n\\n # base d'entrainement affichée avec des croix rouges\\n # base de test affichée avec des ronds bleu\\n\\n pl.show()\\n\\n self.training = False\\n\\n # print(\\\"\\\\nsomme_erreur finale = [\\\" + str(somme_erreur[0]) + \\\",\\\" + str(somme_erreur[1]) + \\\"]\\\")\\n print(\\\"\\\\nTraining done after \\\" + str(n_it) + \\\" iterations !\\\")\\n\\n # version avec arret quand l'erreure augmente\\n # if (somme_erreur[0]+somme_erreur[1]) < (somme_erreur_av[0]+somme_erreur_av[1]) :\\n # self.network.backPropagate(grad, 0.9,0) # grad, pas d'app, moment : permet de lisser la trajectoire\\n # somme_erreur_av = somme_erreur\\n # n_it+=1\\n ##print(\\\"n_it = \\\"+ str(n_it)+\\\"\\\\n\\\")\\n\\n # else :\\n # self.training = False\\n # print(\\\"Training done after \\\" + str(n_it) +\\\" iterations !\\\")\\n\\n while self.running:\\n position = self.robot.get_position()\\n\\n network_input = [0, 0, 0]\\n\\n # calcul de la position relative de la cible dans le referentiel du robot\\n network_input[0] = ((target[0] - position[0]) * math.cos(position[2]) + (\\n target[1] - position[1]) * math.sin(position[2])) * self.alpha[0]\\n network_input[1] = ((target[0] - position[0]) * (-1) * math.sin(position[2]) + (\\n target[1] - position[1]) * math.cos(position[2])) * self.alpha[1]\\n network_input[2] = (-1) * (position[2] - target[2]) * self.alpha[2]\\n\\n command = self.network.runNN(network_input) # propage erreur et calcul vitesses roues instant t\\n print(\\\"command =\\\" + str(command))\\n\\n # dénormaliser la commande\\n command = M * command\\n\\n self.robot.set_motor_velocity(command) # applique vitesses roues instant t,\\n time.sleep(0.050) # attend delta t\\n\\n self.robot.set_motor_velocity([0, 0]) # stop apres arret du prog d'app\\n # position = self.robot.get_position() # obtient nvlle pos robot instant t+1\\n # Teta_t=position[2]\\n\\n self.running = False\",\n \"def train(self, F, Y_batch):\\n H_init = np.array(Y_batch.numpy(), copy=True)\\n H_init[H_init.sum(1) > 1] *= 0\\n H_init = Variable(torch.FloatTensor(H_init))\\n F = Variable(F, requires_grad=True)\\n Z = torch.mm(inv_H(H_init), F)\\n # 1st iteration\\n Z_aug = Z[None].repeat(F.size()[0], 1,1)\\n F_aug = F[:,None].repeat(1,Z.size()[0],1)\\n d = torch.pow(Z_aug- F_aug,2).sum(-1)[...,0] # (N, K) distances to clusters\\n\\n ##\\n mask = np.zeros(Y_batch.numpy().shape)\\n mask[H_init.data.numpy().sum(1) == 1] = 1\\n mask = torch.FloatTensor(mask)\\n\\n tv_Y = Variable(torch.LongTensor((-1*mask*Y_batch + (1-mask)*d.data).numpy().argmin(1) ))\\n py_x = self.lsoftmax(-d)\\n loss = self.nll(py_x, tv_Y)\\n ##\\n loss.backward()\\n G = F.grad.data \\n train_pred = d.data.numpy().argmin(1)\\n return loss.data[0], G, train_pred\",\n \"def train(self, X, y, lr, epoch, method='adam', quit=1e-4):\\n if len(y.shape) == 1:\\n y = y.reshape((-1, 1))\\n if not (0 < lr < 1):\\n raise self.ANNException('learning rate cannot be negative or exceeds 1')\\n if epoch <= 0:\\n raise self.ANNException('epoch must be postitive integer')\\n if method == 'gd':\\n for _ in range(epoch):\\n nodes = self._forward(X)\\n self._backpropagate(y, nodes, lr)\\n elif method == 'adam':\\n alpha = 0.1\\n beta1 = 0.5\\n beta2 = 0.999\\n epsilon = 1e-8\\n mt = np.zeros(shape=self.weight.shape)\\n vt = np.zeros(shape=self.weight.shape)\\n before_err = self._energy(X, y)\\n for t in range(1, epoch+1):\\n nodes = self._forward(X)\\n gt = self._backpropagate(y, nodes, alpha, ret=True)\\n mt = beta1*mt + (1-beta1)*gt\\n vt = beta2*vt + (1-beta2)*gt**2\\n mthat = mt / (1-np.power(beta1, t))\\n vthat = vt / (1-np.power(beta2, t))\\n self.weight -= alpha * mthat/(np.sqrt(vthat)+epsilon)\\n after_err = self._energy(X, y)\\n if 0 < after_err-before_err < quit:\\n return\\n else:\\n before_err = after_err\\n else:\\n raise self.ANNException('only gd and adam optimizer are supported')\",\n \"def train_gd(self,f,x,y,learnrate=0.0001,T=1000):\\n f = copy.deepcopy(f)\\n loss = numpy.zeros(T)\\n t = 0\\n deltal = -numpy.inf\\n while (t<T) and (deltal<1e-7):\\n (loss[t],dldw) = self(f,x,y)\\n f.w = f.w -learnrate*dldw\\n\\n if (numpy.remainder(t,100)==0):\\n print('Epoch %d: loss=%f' % (t,loss[t]))\\n if (t>0):\\n deltal = loss[t]-loss[t-1]\\n t += 1\\n \\n return (f,loss)\",\n \"def run_steep_gradient_descent(data_x, data_y, len_data, alpha, theta):\\n n = len_data\\n # WE NEED TO transpose data_x into (p+1) *n ,theta is 1*(p+1)\\n prod = np.dot(theta, data_x.transpose())\\n\\n prod -= data_y\\n print(\\\"pro: data_x\\\", prod.shape, data_x.shape)\\n #prod represent the loss of the hypothesis and true label\\n sum_grad = np.dot(prod, data_x)\\n print(\\\"总梯度的值：\\\",sum_grad.shape)\\n\\n # batch-gradient descent\\n theta = theta -(alpha / n) * sum_grad\\n return theta\",\n \"def train(self):\\n df = self.df\\n self.scaler = MinMaxScaler()\\n self.scaler.fit(df)\\n df[df.columns] = self.scaler.transform(df)\\n\\n\\n X_train, y_train = get_X_y(df, self.n_days, self.length , self.style)\\n X_train = np.array(X_train)\\n X_train.shape = (X_train.shape[0], X_train.shape[2])\\n\\n self.clf = LogisticRegression().fit(X_train, y_train)\\n\\n #es = EarlyStopping(monitor = 'accuracy',mode = 'min' , verbose = 1, patience = 100, restore_best_weights = True)\",\n \"def train(self, X, y):\\n tf.logging.set_verbosity(\\n tf.logging.INFO) # comment if you don't want to display the information during training/evaluation\\n\\n X_train, X_test, y_train, y_test = train_test_split(\\n X, y, test_size=self.params[\\\"TEST_SIZE\\\"], random_state=42, stratify=y)\\n\\n self.label_list = y.unique()\\n\\n train_features = self.sentences_to_features(X_train, y_train)\\n test_features = self.sentences_to_features(X_test, y_test)\\n if DEBUG:\\n print(\\\"Transformation to features completed\\\")\\n\\n num_train_steps = int(\\n len(train_features) / self.params[\\\"BATCH_SIZE\\\"] * self.params[\\\"NUM_TRAIN_EPOCHS\\\"])\\n num_warmup_steps = int(\\n num_train_steps * self.params[\\\"WARMUP_PROPORTION\\\"])\\n\\n run_config = self.run_config_builder()\\n model_fn = self.model_fn_builder(len(self.label_list), self.params[\\\"LEARNING_RATE\\\"], num_train_steps,\\n num_warmup_steps)\\n self.estimator = self.estimator_builder(model_fn, run_config)\\n\\n train_input_fn = bert.run_classifier.input_fn_builder(features=train_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=True, drop_remainder=False)\\n if DEBUG:\\n print(\\\"Beginning Training!\\\")\\n current_time = time.time()\\n self.estimator.train(input_fn=train_input_fn,\\n max_steps=num_train_steps)\\n if DEBUG:\\n print(\\\"Training took time :\\\", time.time() - current_time,\\n \\\"s, or \\\", (time.time() - current_time) / 60, \\\"min\\\")\\n\\n self.classifier_trained = True\\n\\n test_input_fn = run_classifier.input_fn_builder(features=test_features,\\n seq_length=self.params[\\\"MAX_SEQ_LENGTH\\\"],\\n is_training=False, drop_remainder=False)\\n\\n # apply model on test set and print all metrics\\n if DEBUG:\\n print(\\\"Evaluating\\\")\\n self.estimator.evaluate(input_fn=test_input_fn, steps=None)\",\n \"def linear_classifier(position_array, class_array, n_classes):\\n\\n # linear classifier\\n with tf.Graph().as_default():\\n # YOUR CODE FOR PROBLEM 6A GOES HERE\\n # Build neural network\\n net = tflearn.input_data(shape=[None, 2])\\n # 'None' always has to be the first parameter in shape because it tells\\n # tensor flow that the number of data points we have can be variable\\n # and 2 for 2 input nodes (x and y coordinates)\\n\\n net = tflearn.fully_connected(net, n_classes, activation='softmax') # layer with 4 nodes and softmax\\n net = tflearn.regression(net, loss='categorical_crossentropy') #regression with categorical_crossentropy\\n\\n # Define model\\n model = tflearn.DNN(net)\\n new_class_array = np.zeros((len(class_array), 4))\\n index = 0\\n\\n #change to be 4 dimensional\\n for x in class_array:\\n if x == 0:\\n new_class_array[index] = [1,0,0,0]\\n elif x == 1:\\n new_class_array[index] = [0,1,0,0]\\n elif x == 2:\\n new_class_array[index]= [0,0,1,0]\\n elif x == 3:\\n new_class_array[index] = [0,0,0,1]\\n index +=1 \\n\\n # Start training (apply gradient descent algorithm)\\n model.fit(position_array, new_class_array, n_epoch=10, batch_size=10, show_metric=True, snapshot_step=1)\\n return position_array, new_class_array, model\",\n \"async def train(gradient_boosting: bool = False) -> bool:\\n data = clf.dataset()\\n return clf.train(data['X'], data['y'], gradient_boosting)\",\n \"def train(self, X, y):\\r\\n # the nearest neighbor classifier simply remembers all the training data\\r\\n self.Xtr = X\\r\\n self.ytr = y\",\n \"def train(self, X, y):\\n # the nearest neighbor classifier simply remembers all the training data\\n self.Xtr = X\\n self.ytr = y\",\n \"def train(self, X, y):\\n # the nearest neighbor classifier simply remembers all the training data\\n self.Xtr = X\\n self.ytr = y\",\n \"def train(self, X_, y, reg=1e-4, lr=0.1, epochs=5, batch_size=16):\\n # set up classes and make y into a matrix 1 in k encoded\\n self.classes = np.sort(np.unique(y))\\n num_classes = self.classes.size\\n y_as_matrix = np.zeros((y.size, num_classes))\\n y_as_matrix[np.arange(y.shape[0]), y] = 1\\n X = np.c_[np.ones(X_.shape[0]), X_] # add bias variable 1\\n ### YOUR CODE HERE\\n self.w = soft_reg.mini_batch_grad_descent(X, y_as_matrix, reg=reg, lr=lr, epochs=epochs, batch_size=batch_size)\\n ### END CODE\",\n \"def train(self, X, y):\\n m,d = X.shape\\n D = np.array([1/m] * m)\\n for t in range(self.T):\\n self.h[t] = self.WL(D,X,y)\\n h_t = self.h[t].predict(X)\\n epsilon_t = np.sum(np.logical_not(y==h_t) * D)\\n self.w[t] = 0.5 * np.log((1/epsilon_t) - 1)\\n n = np.sum([D * np.exp(-1 * self.w[t] * y * h_t)])\\n D = (D * np.exp(-1 * self.w[t] * y * h_t)) / n\",\n \"def train(self, train_set, shuffle_batch=True,\\n epochs=25, lr_decay=0.95, sqr_norm_lim=9,labels=None,model=None): \\n cost = self.negative_log_likelihood(self.y) \\n dropout_cost = self.dropout_negative_log_likelihood(self.y)\\n # adadelta upgrades: dict of variable:delta\\n grad_updates = self.sgd_updates_adadelta(dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\\n # shuffle dataset and assign to mini batches.\\n # if dataset size is not a multiple of batch size, replicate \\n # extra data (at random)\\n np.random.seed(3435)\\n batch_size = self.batch_size\\n if train_set.shape[0] % batch_size > 0:\\n extra_data_num = batch_size - train_set.shape[0] % batch_size\\n #extra_data = train_set[np.random.choice(train_set.shape[0], extra_data_num)]\\n perm_set = np.random.permutation(train_set) \\n extra_data = perm_set[:extra_data_num]\\n new_data = np.append(train_set, extra_data, axis=0)\\n else:\\n new_data = train_set\\n \\n shuffled_data = np.random.permutation(new_data) # Attardi\\n n_batches = shuffled_data.shape[0]/batch_size\\n # divide train set into 90% train, 10% validation sets\\n n_train_batches = int(np.round(n_batches*0.8))\\n n_val_batches = n_batches - n_train_batches\\n train_set = shuffled_data[:n_train_batches*batch_size,:]\\n val_set = shuffled_data[n_train_batches*batch_size:,:] \\n # push data to gpu \\n # the dataset has the format [word_indices,padding,user,label]\\n train_set_x, train_set_y = shared_dataset(train_set[:,:-2], train_set[:,-1]) \\n train_set_u = theano.shared(np.asarray(train_set[:,-2],dtype='int32')) \\n val_set_x = val_set[:,:-2]\\n val_set_u = val_set[:,-2]\\n val_set_y = val_set[:,-1]\\n # val_set_x, val_set_y = shared_dataset(val_set[:,:-1], val_set[:,-1])\\n batch_start = self.index * batch_size\\n batch_end = batch_start + batch_size\\n\\n \\n \\n # compile Theano functions to get train/val/test errors\\n \\n # val_model = theano.function([self.index], self.errors(self.y),\\n # givens={\\n # self.x: val_set_x[batch_start:batch_end],\\n # self.y: val_set_y[batch_start:batch_end]},\\n # allow_input_downcast=True)\\n\\n # errors on train set\\n if self.Users is not None:\\n train_model = theano.function([self.index], cost, updates=grad_updates,\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end],\\n self.u: train_set_u[batch_start:batch_end]\\n },\\n allow_input_downcast = True)\\n\\n train_error = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end],\\n self.u: train_set_u[batch_start:batch_end]},\\n allow_input_downcast=True)\\n else:\\n train_model = theano.function([self.index], cost, updates=grad_updates,\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end]},\\n allow_input_downcast = True)\\n\\n train_error = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end]},\\n allow_input_downcast=True)\\n\\n #FIXME: this is a bit weird\\n test_y_pred = self.predict(val_set_x)\\n make_preds = theano.function([self.x], test_y_pred, allow_input_downcast=True)\\n\\n test_error = T.mean(T.neq(test_y_pred, self.y))\\n test_model = theano.function([self.x, self.y], test_error, allow_input_downcast=True)\\n\\n\\n # start training over mini-batches\\n print 'training...' \\n best_val_perf = 0\\n test_perf = 0 \\n patience = 5\\n drops = 0\\n prev_val_perf = 0 \\n for epoch in xrange(epochs):\\n start_time = time.time()\\n # FIXME: should permute whole set rather than minibatch indexes\\n if shuffle_batch:\\n for minibatch_index in np.random.permutation(range(n_train_batches)):\\n cost_epoch = train_model(minibatch_index)\\n self.set_zero(self.zero_vec) # CHECKME: Why?\\n else:\\n for minibatch_index in xrange(n_train_batches):\\n cost_epoch = train_model(minibatch_index) \\n self.set_zero(self.zero_vec)\\n train_losses = [train_error(i) for i in xrange(n_train_batches)]\\n train_perf = 1 - np.mean(train_losses)\\n # test_loss = test_model(val_set_x, val_set_y)\\n # test_perf = 1 - test_loss \\n # predz = make_preds(val_set_x)\\n # val_perf = FmesSemEval(predz, val_set_y, pos_ind, neg_ind)\\n val_perf = 0\\n info = 'epoch: %i\\\\%i (%.2f secs) train acc: %.2f %% | val avg fmes: %.2f %%' % (\\n epoch,epochs, time.time()-start_time, train_perf * 100., val_perf*100.) \\n # from ipdb import set_trace; set_trace()\\n if val_perf > prev_val_perf: \\n drops=0\\n if val_perf >= best_val_perf:\\n best_val_perf = val_perf\\n info+= \\\" **\\\"\\n if model:\\n # print \\\"save model\\\"\\n self.save(model)\\n # test_loss = test_wmodel(val_set_x, val_set_y)\\n # test_perf = 1 - test_loss \\n # predz = make_preds(val_set_x)\\n # fmes = FmesSemEval(predz, val_set_y, pos_ind, neg_ind)\\n # print predz\\n # print test_set_y\\n # print \\\"Test performance acc: %.3f | polar fmes:%.3f \\\" % (test_perf,fmes)\\n else: \\n drops+=1\\n if drops >= patience:\\n print \\\"Ran out of patience...\\\"\\n break\\n prev_val_perf = val_perf\\n print info\\n return test_perf\",\n \"def non_linear_classifier(position_array, class_array, n_classes):\\n with tf.Graph().as_default():\\n # YOUR CODE FOR PROBLEM 6C GOES HERE\\n # Build neural network\\n net = tflearn.input_data(shape=[None, 2])\\n # 'None' always has to be the first parameter in shape because it tells\\n # tensor flow that the number of data points we have can be variable\\n # and 2 for 2 input nodes (x and y coordinates)\\n #sgd = tflearn.optimizers.SGD(learning_rate=2.0, lr_decay=0.5, decay_step=100)\\n\\n net = tflearn.fully_connected(net, 20000, activation='relu') # 20,0000 nodes\\n net = tflearn.fully_connected(net, n_classes, activation='softmax') # layer with 4 nodes and softmax\\n net = tflearn.regression(net, loss='categorical_crossentropy') #regression with categorical_crossentropy\\n\\n # Define model\\n model = tflearn.DNN(net)\\n new_class_array = np.zeros((len(class_array), 4))\\n index = 0\\n\\n #change to be four dimensional\\n for x in class_array:\\n if x == 0:\\n new_class_array[index] = [1,0,0,0]\\n elif x == 1:\\n new_class_array[index] = [0,1,0,0]\\n elif x == 2:\\n new_class_array[index]= [0,0,1,0]\\n elif x == 3:\\n new_class_array[index] = [0,0,0,1]\\n index +=1 \\n\\n # Start training (apply gradient descent algorithm)\\n model.fit(position_array, new_class_array, n_epoch=10, batch_size=10, show_metric=True, snapshot_step=1)\\n return position_array, new_class_array, model\",\n \"def stochastic_grad_descent(X, y, alpha=0.1, lambda_reg=1, num_iter=1000, checkin=100):\\n num_instances, num_features = X.shape[0], X.shape[1]\\n theta = np.ones(num_features) #Initialize theta\\n theta_hist = np.zeros((num_iter, num_instances, num_features)) #Initialize theta_hist\\n loss_hist = np.zeros((num_iter, num_instances)) #Initialize loss_hist\\n epoch = 1\\n while epoch < num_iter:\\n instance = 1\\n while instance < num_instances:\\n if alpha == \\\"1/sqrt(t)\\\":\\n alpha_0 = .01/np.sqrt(instance)\\n elif alpha == \\\"1/t\\\":\\n alpha_0 = .01/float(instance)\\n else:\\n alpha_0 = alpha\\n index = np.random.randint(num_instances)\\n vec = np.reshape(X[index,:].T,(1,49))\\n grad = compute_regularized_square_loss_gradient(vec,y[index],theta,lambda_reg)\\n theta = theta - alpha_0*grad\\n theta_hist[epoch][instance] = theta\\n loss_hist[epoch][instance] = compute_square_loss(vec,y[index],theta)\\n instance += 1\\n\\n if type(checkin) is int and epoch%checkin==0:\\n print(\\\"completed training epoch {}...\\\".format(epoch))\\n \\n epoch += 1\\n\\n return theta_hist, loss_hist\",\n \"def loss_and_grad(self, X, y):\\n\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n grad = np.zeros_like(self.W)\\n grad_tmp = np.zeros_like(self.W)\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and the gradient. Store the gradient\\n # as the variable grad.\\n # ================================================================ #\\n \\n exp_a = np.zeros((num_classes,num_train))\\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n \\n #if i==0:\\n grada = np.zeros(X.shape[1])\\n \\n for j in range(num_classes):\\n if j != y[i]:\\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) \\n else: \\n grad_tmp[j,:] = X[i,:].T * (exp_a[j,i] / np.sum(exp_a[:,i])) - X[i,:].T \\n\\n grad += grad_tmp\\n loss += Loss \\n \\n pass\\n\\n\\n loss /= num_train\\n grad /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def LSTM_train(X_train, Y_train, X_dev, Y_dev, R_train, R_dev, hyperparams):\",\n \"def train_all(X_train_fuse, Y_train, X_dev_fuse, Y_dev, R_train, R_dev, hyperparams):\",\n \"def fit(self, X, y):\\n # Make sure inputs are numpy arrays.\\n X = np.array(X)\\n y = np.array(y)\\n # Add x_0 = 1 to each instance for the bias term.\\n X = np.c_[np.ones((X.shape[0], 1)), X]\\n # Store number of samples and features in variables.\\n n_samples, n_features = np.shape(X)\\n self.training_errors = []\\n # Initialize weights randomly from normal distribution.\\n self.coef_ = np.random.randn(n_features, 1)\\n # Batch gradient descent for number iterations = n_iter.\\n for _ in range(self.n_iter):\\n y_preds = X.dot(self.coef_)\\n # Penalty term if regularized (don't include bias term).\\n regularization = self.regularization(self.coef_[1:])\\n # Calculate mse + penalty term if regularized.\\n cost_function = mean_squared_error(y, y_preds) + regularization\\n if cost_function > self.threshold:\\n break\\n self.training_errors.append(cost_function) \\n # Regularization term of gradients (don't include bias term).\\n gradient_reg = self.regularization.grad(self.coef_[1:])\\n # Gradients of loss function.\\n gradients = (2/n_samples) * X.T.dot(y_preds - y)\\n gradients += gradient_reg\\n # Update the weights.\\n self.coef_ -= (self.lr * gradients.sum(axis=1)).reshape(-1, 1)\\n\\n return self\",\n \"def train(self):\\n self._stop_gradient = False\",\n \"def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\\\"Delta\\\"):\\r\\n for i in range(num_epochs):\\r\\n bse = 0 \\r\\n for j in range(X.shape[1]//batch_size):\\r\\n x_bs = X[:,bse:bse+batch_size]\\r\\n y_bs = y[:,bse:bse+batch_size]\\r\\n diff = np.subtract(y_bs, self.predict(x_bs))\\r\\n bse+=batch_size\\r\\n\\r\\n if learning.lower() == \\\"filtered\\\":\\r\\n self.weights = (1-gamma)*self.weights + alpha*(np.dot(y_bs, x_bs.T))\\r\\n elif learning.lower() == \\\"delta\\\":\\r\\n self.weights = self.weights + alpha*(np.dot(diff, x_bs.T))\\r\\n\\r\\n else:\\r\\n self.weights = self.weights + alpha*(np.dot(self.predict(x_bs), x_bs.T))\",\n \"def train_logistic_regression(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> LogisticRegressionClassifier:\\n lr = LogisticRegressionClassifier(feat_extractor.corpus_length, feat_extractor)\\n alpha = 1e0\\n # beta = 1e-4\\n for epoch in range(8):\\n loss = 0.\\n acc = 0\\n indices = np.arange(len(train_exs))\\n np.random.shuffle(indices)\\n for i in indices:\\n feat = feat_extractor.feats[i]\\n sentimentExample = train_exs[i]\\n y = sentimentExample.label\\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z) \\\\\\n # + beta * np.expand_dims(lr.w, axis=0).dot(np.expand_dims(lr.w, axis=1))[0, 0]\\n predict = int(feat.dot(np.expand_dims(lr.w, axis=1))[0, 0] > 0)\\n acc += (predict == y)\\n grad = (z - y) * feat.toarray()[0] # + 2 * beta * lr.w\\n lr.w = lr.w - alpha * grad\\n print(\\\"epoch {:d}, loss: {:f}, accuracy: {:f}\\\".format(epoch, loss / len(train_exs), acc / len(train_exs)))\\n\\n for i in indices:\\n feat = feat_extractor.feats[i]\\n sentimentExample = train_exs[i]\\n y = sentimentExample.label\\n z = 1 / (1 + np.exp(-feat.dot(np.expand_dims(lr.w, axis=1))))[0, 0]\\n loss += -y * np.log(z) - (1 - y) * np.log(1 - z)\\n print(\\\"training loss: {:f}\\\".format(loss / len(train_exs)))\\n\\n return lr\",\n \"def train(self, X, y, X_val, y_val,\\n alpha=1e-3, alpha_decay=0.95,\\n reg=1e-5, num_iters=100,\\n batch_size=100):\\n num_train = X.shape[0]\\n iteration = max(num_train / batch_size, 1)\\n\\n loss_train = []\\n train_acc = []\\n val_acc = []\\n\\n for it in range(num_iters):\\n print('iteration '+str(it))\\n data_batch = None\\n label_batch = None\\n \\n #########################################################################\\n # create a random batch of data and labels for\\n indx = np.random.permutation(len(X))\\n data, labels = X[indx], y[indx]\\n data_batch = data[0:batch_size]\\n label_batch = labels[0:batch_size]\\n #########################################################################\\n pass\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n # calculate loss and gradients\\n loss, gradient = self.loss(data_batch, y=label_batch, reg=reg)\\n loss_train.append(loss)\\n #########################################################################\\n # update weights and biases which stored in the slef.p_net regarding \\n # to gradient dictionary.\\n self.p_net['W1'] -= alpha * gradient['W1']\\n self.p_net['b1'] -= alpha * gradient['b1']\\n self.p_net['W2'] -= alpha * gradient['W2']\\n self.p_net['b2'] -= alpha * gradient['b2']\\n #########################################################################\\n pass\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n if it % 100 == 0:\\n print ('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n \\n if it % iteration == 0:\\n # Check accuracy\\n train_acc_ = (self.predict(data_batch) == label_batch).mean()\\n val_acc_ = (self.predict(X_val) == y_val).mean()\\n train_acc.append(train_acc_)\\n val_acc.append(val_acc_)\\n\\n alpha *= alpha_decay\\n\\n return {\\n 'loss_train': loss_train,\\n 'train_acc': train_acc,\\n 'val_acc': val_acc,\\n }\",\n \"def train(self, X, y, learning_rate=1e-3, num_iters=100,\\n batch_size=200, verbose=True):\\n num_train, dim = X.shape\\n\\n if self.w is None:\\n self.w = 0.001 * np.random.randn(dim)\\n\\n loss_history = []\\n\\n # 将feature与label连起来，方便后面batch的划分\\n all_data = list(zip(X, y))\\n\\n for it in xrange(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n #########################################################################\\n # TODO: #\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n\\n # batch_data = np.random.choice(all_data, batch_size, False) \\n # error: ValueError: a must be 1-dimensional \\n # 查询相关api貌似该方法不能用于数组中元素为元组情况下的选取\\n batch_data = random.sample(all_data, batch_size)\\n X_batch, y_batch = zip(*batch_data)\\n X_batch = np.array(X_batch)\\n y_batch = np.array(y_batch)\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n # evaluate loss and gradient\\n\\n loss, grad = self.loss(X_batch, y_batch)\\n loss_history.append(loss)\\n\\n # perform parameter update\\n #########################################################################\\n # TODO: #\\n # Update the weights using the gradient and the learning rate. #\\n #########################################################################\\n self.w += float(learning_rate) * np.array(grad)\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n if verbose and (it % 1000 == 0 or it == num_iters - 1):\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def fit(self, X, y, max_iter=MAX_ITER):\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n start = time.time()\\n cost_function = 0\\n for t in range(n_tasks):\\n #print('Training {} task with lasso regression'.format(t))\\n lasso = Lasso(alpha=self.lambda_1, positive=self.positive, max_iter=max_iter)\\n lasso.fit(X[t], y[t])\\n W[:, t] = lasso.coef_\\n cost_function += np.linalg.norm(np.dot(X[t], W[:, t]) - y[t]) \\\\\\n + sum(abs(W[:, t]))\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def train(self, X, y):\\n pass\",\n \"def evaluate(self, train_set, test_set, shuffle_batch=True,\\n epochs=25, lr_decay=0.95, sqr_norm_lim=9,labels=None,model=None): \\n cost = self.negative_log_likelihood(self.y) \\n dropout_cost = self.dropout_negative_log_likelihood(self.y)\\n # adadelta upgrades: dict of variable:delta\\n grad_updates = self.sgd_updates_adadelta(dropout_cost, lr_decay, 1e-6, sqr_norm_lim)\\n # shuffle dataset and assign to mini batches.\\n # if dataset size is not a multiple of batch size, replicate \\n # extra data (at random)\\n np.random.seed(3435)\\n batch_size = self.batch_size\\n if train_set.shape[0] % batch_size > 0:\\n extra_data_num = batch_size - train_set.shape[0] % batch_size\\n #extra_data = train_set[np.random.choice(train_set.shape[0], extra_data_num)]\\n perm_set = np.random.permutation(train_set) \\n extra_data = perm_set[:extra_data_num]\\n new_data = np.append(train_set, extra_data, axis=0)\\n else:\\n new_data = train_set\\n \\n shuffled_data = np.random.permutation(new_data) # Attardi\\n n_batches = shuffled_data.shape[0]/batch_size\\n # divide train set into 90% train, 10% validation sets\\n n_train_batches = int(np.round(n_batches*0.8))\\n n_val_batches = n_batches - n_train_batches\\n train_set = shuffled_data[:n_train_batches*batch_size,:]\\n val_set = shuffled_data[n_train_batches*batch_size:,:] \\n # push data to gpu \\n # the dataset has the format [word_indices,padding,user,label]\\n train_set_x, train_set_y = shared_dataset(train_set[:,:-2], train_set[:,-1]) \\n train_set_u = theano.shared(np.asarray(train_set[:,-2],dtype='int32')) \\n # val_set_x = val_set[:,:-2]\\n # val_set_u = val_set[:,-2]\\n # val_set_y = val_set[:,-1]\\n val_set_x, val_set_y = shared_dataset(val_set[:,:-2], val_set[:,-1])\\n val_set_u = theano.shared(np.asarray(val_set[:,-2],dtype='int32')) \\n test_set_x = test_set[:,:-2]\\n test_set_u = test_set[:,-2]\\n test_set_y = test_set[:,-1] \\n batch_start = self.index * batch_size\\n batch_end = batch_start + batch_size\\n\\n # compile Theano functions to get train/val/test errors\\n \\n \\n test_y_pred = self.predict(test_set_x,test_set_u)\\n test_error = T.mean(T.neq(test_y_pred, self.y))\\n # errors on train set\\n if self.Users is not None:\\n train_model = theano.function([self.index], cost, updates=grad_updates,\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end],\\n self.u: train_set_u[batch_start:batch_end]\\n },\\n allow_input_downcast = True)\\n\\n train_error = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end],\\n self.u: train_set_u[batch_start:batch_end]},\\n allow_input_downcast=True)\\n val_model = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: val_set_x[batch_start:batch_end],\\n self.y: val_set_y[batch_start:batch_end], \\n self.u: val_set_u[batch_start:batch_end]},\\n allow_input_downcast=True)\\n test_model = theano.function([self.x, self.u, self.y], test_error, allow_input_downcast=True)\\n else:\\n train_model = theano.function([self.index], cost, updates=grad_updates,\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end]},\\n allow_input_downcast = True)\\n\\n train_error = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: train_set_x[batch_start:batch_end],\\n self.y: train_set_y[batch_start:batch_end]},\\n allow_input_downcast=True)\\n\\n val_model = theano.function([self.index], self.errors(self.y),\\n givens={\\n self.x: val_set_x[batch_start:batch_end],\\n self.y: val_set_y[batch_start:batch_end]},\\n allow_input_downcast=True)\\n test_model = theano.function([self.x, self.y], test_error, allow_input_downcast=True)\\n\\n # start training over mini-batches\\n print 'training...' \\n best_val_perf = 0\\n test_perf = 0 \\n patience = 5\\n drops = 0\\n prev_val_perf = 0 \\n for epoch in xrange(epochs):\\n start_time = time.time()\\n # FIXME: should permute whole set rather than minibatch indexes\\n if shuffle_batch:\\n for minibatch_index in np.random.permutation(range(n_train_batches)):\\n cost_epoch = train_model(minibatch_index)\\n self.set_zero(self.zero_vec) # CHECKME: Why?\\n else:\\n for minibatch_index in xrange(n_train_batches):\\n cost_epoch = train_model(minibatch_index) \\n self.set_zero(self.zero_vec)\\n train_losses = [train_error(i) for i in xrange(n_train_batches)]\\n train_perf = 1 - np.mean(train_losses)\\n val_losses = [val_model(i) for i in xrange(n_val_batches)]\\n val_perf = 1 - np.mean(val_losses) \\n info = 'epoch: %i\\\\%i (%.2f secs) train acc: %.2f %% | val acc: %.2f %%' % (\\n epoch,epochs, time.time()-start_time, train_perf * 100., val_perf*100.) \\n # from ipdb import set_trace; set_trace()\\n if val_perf > prev_val_perf: \\n drops=0\\n if val_perf >= best_val_perf:\\n best_val_perf = val_perf\\n info+= \\\" **\\\"\\n if model:\\n # print \\\"save model\\\"\\n self.save(model)\\n if self.Users is not None:\\n test_loss = test_model(test_set_x, test_set_u, test_set_y)\\n else:\\n test_loss = test_model(test_set_x, test_set_y)\\n test_perf = 1 - test_loss \\n else: \\n drops+=1\\n if drops >= patience:\\n print \\\"Ran out of patience...\\\"\\n break\\n prev_val_perf = val_perf\\n print info\\n # set_trace() \\n return test_perf\",\n \"def learn(self, Xtrain, ytrain):\\n pass\\n self.weights = np.zeros(Xtrain.shape[1],)\\n\\n ### YOUR CODE HERE\\n \\n lmbd = self.params['lamb']\\n \\n numsamples = Xtrain.shape[0]\\n # Xless = Xtrain[:,self.params['features']]\\n Xless = Xtrain\\n self.weights = np.random.rand(Xless.shape[1])\\n err = 10000;\\n #cw =0;\\n tolerance = 10*np.exp(-4)\\n i=0;\\n \\n \\n w1 = self.weights\\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain) + lmbd * self.regularizer[0](self.weights)\\n # print(cw)\\n errors = []\\n runtm = []\\n epch = []\\n \\n err = 1\\n iteration= 1000\\n #tm= time.time()\\n while (abs(cw-err)>tolerance) and (i <iteration):\\n err = cw\\n g = self.logit_cost_grad(cw_v, Xless, ytrain)\\n obj = cw\\n j=0\\n ita = -1* self.params['stepsize']\\n w = self.weights\\n # w1 = np.add(w,np.dot(ita,g))\\n while(j<iteration):\\n w1 = np.add(w,np.dot(ita,g))\\n # cw_v =(np.dot(Xless, w1)-ytrain)\\n # cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, w1.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)+lmbd * self.regularizer[0](w1)\\n ## print (cw)\\n \\n if(cw<np.absolute(obj-tolerance)): ############################################\\n break\\n ita = 0.7*ita\\n j=j+1\\n \\n if(j==iteration):\\n self.weights=w\\n ita =0\\n else:\\n self.weights = w1\\n \\n # cw_v =(np.dot(Xless, self.weights)-ytrain)\\n #cw = (np.linalg.norm(cw_v)**2)/(2*numsamples)\\n cw_v = np.dot(Xless, self.weights.T)\\n cw = self.logit_cost(cw_v, Xless, ytrain)\\n #tm1 = time.time()-tm\\n #runtm.append(tm1)\\n #err = cw\\n errors.append(err)\\n i=i+1\\n epch.append(i)\",\n \"def learn2_sgd():\\n\\n sgd.fit(vector_training,sentiment_training) ##fits the training data of vector tweets and sentiments using SGDClassifier\\n correct = 0\\n for i in range(vector_testing.shape[0]): ##using the testing, data see how accurate SGDC is\\n prediction = sgd.predict(vector_testing[i])\\n sentiment = sentiment_testing[i]\\n if prediction[0] == sentiment:\\n correct +=1\\n \\n accuracy = correct/vector_testing.shape[0]\\n print('Stochastic Gradient Descent Classifier Testing Accuracy: {:.2f}'.format(accuracy)) ##prints the accuracy of the algorithm\",\n \"def train(self, network, training_examples, iterations, unsupervised=False):\\n if unsupervised:\\n # For now this means we are training a sparse autoencoder.\\n # Therefore, we need to keep a running estimate of the\\n # \\\"sparsity\\\" of a node, where we try to keep the activation\\n # of the node stay close to a small value near 0 known as\\n # rho (Greek lower case p) or the 'sparsity parameter',\\n # which we will set to 0.05.\\n # This forces the network to learn the smallest set of features\\n # necessary to accurately build a close estimate of the original\\n # input vector\\n # In this case, we set the input vector equal to the target vector,\\n # and usually set a smaller value for the number of hidden nodes\\n # Then perform normal backpropagation, and during that, for each\\n # hidden node, also update the rho_estimate, and then update the\\n # threshold value\\n rho = 0.05\\n rho_estimates = [0] * len(network.layers[0].neurons) # set to 0 for each node\\n beta = 0.2 # the learning rate for updating the threshold terms\\n for iteration_counter in range(iterations):\\n random.shuffle(training_examples)\\n # for each row of data\\n for training_example in training_examples:\\n input_vector = training_example[0]\\n target_output_vector = training_example[1]\\n # prime the network on this row of input data\\n # -this will cause output (activation) values to be\\n # set for each neuron\\n network.forward(input_vector)\\n\\n # Note: next_layer_deltas is a vector of the single\\n # delta values for each node in the next\\n # (forward) layer\\n next_layer_deltas = []\\n next_layer_weights = []\\n isOutputLayer = True\\n for layer in reversed(network.layers): # iterate backwards\\n this_layer_deltas = [] # values from current layer\\n this_layer_weights = []\\n for j, neuron in enumerate(layer.neurons):\\n derivative = neuron.activation_function.derivative\\n # The output layer neurons are treated slightly\\n # different than the hidden neurons\\n if isOutputLayer:\\n if neuron.activation_function.name == \\\"logistic\\\":\\n # derivative simplifies down to just\\n # subtracting the target from the\\n # hypothesis\\n delta = neuron.output - target_output_vector[j]\\n else: # Tanh or Linear\\n delta = (neuron.output-target_output_vector[j])*derivative(neuron.output)\\n else: # for the hidden layer neurons\\n # Need to sum the products of the delta of\\n # a neuron in the next (forward) layer and the\\n # weight associated with the connection between\\n # this hidden layer neuron and that neuron.\\n # This will basically determine how much this\\n # neuron contributed to the error of the neuron\\n # it is connected to\\n # Note: next_layer_deltas is a vector of the \\n # single delta values for each node in the next\\n # (forward) layer\\n sum_value = 0.0\\n for next_delta, weights in zip(next_layer_deltas,\\n next_layer_weights):\\n sum_value += weights[j] * next_delta\\n delta = (derivative(neuron.output) *\\n sum_value)\\n # now store the delta and the list of weights\\n # for this neuron into these storage lists for the\\n # whole layer\\n this_layer_deltas.append(delta)\\n this_layer_weights.append(neuron.weights)\\n # Now, compute the gradient (partial deriv of cost\\n # func, J, w/ respect to parameter ij) for each\\n # weight_ij (parameter_ij) associated with\\n # this neuron\\n for ij, input_ij in enumerate(neuron.input_vector):\\n # compute gradient (partial deriv of cost J w/\\n # respect to parameter ij)\\n # Note: index ij means from a previous\\n # layer node i to this layer node j\\n # Then Gradient Descent: multiply by the learning\\n # rate, and subtract from the current value\\n # Note: Subtract in order to minimize error, since\\n # partial derivs point in direction of gradient\\n # AScent\\n gradient_ij = delta * input_ij\\n neuron.weights[ij] -= self.learning_rate * gradient_ij\\n # Now, compute the gradient (partial deriv of cost\\n # func, J, with respect to parameter ij) for the\\n # threshold value (parameter_0j), by using a \\\"1\\\" as\\n # the threshold \\\"input value\\\"\\n # -Note: index 0j means from a previous\\n # layer threshold node 0 (threshold always has\\n # index i=0) to this layer node j\\n # -can also think of it as the threshold being\\n # internal to this neuron\\n gradient_0j = delta * 1\\n neuron.threshold -= self.learning_rate * gradient_0j\\n if unsupervised and not isOutputLayer:\\n rho_estimates[j] = (0.999*rho_estimates[j] +\\n 0.001*neuron.output)\\n neuron.threshold -= (self.learning_rate * beta *\\n (rho_estimates[j] - rho))\\n # Once this layer is done, store the gradients and weights\\n # from the current layer for the next layer iteration\\n # (moving backwards)\\n next_layer_deltas = this_layer_deltas\\n next_layer_weights = this_layer_weights\\n isOutputLayer = False\\n # Note: this is after the while loop\\n self.iterations = iteration_counter\",\n \"def __init__(self, train_data, validation=None, initial_weight=None,\\n loss_function_name='mse', cal_weight='gradient',\\n regularizer=None, regularizer_p=None):\\n self.train_x = train_data[1]\\n self.train_y = train_data[0]\\n\\n self.set_valid(validation)\\n\\n ''' Define the progress of history here '''\\n self.losses = []\\n self.iterations = 0\\n self.weights = []\\n self.misclass_rate = []\\n\\n ''' Define loss, weight calculation, regularizer '''\\n self.loss_function = get_loss_function(loss_function_name)\\n self.loss_function_name = loss_function_name\\n self.calculate_weight = cal_weight\\n self.regularizer = Regularizer.get_regularizer(regularizer, regularizer_p)\\n self.regularizer_p = regularizer_p\\n\\n # Asserting degree\\n if len(self.train_x.shape) > 1:\\n degree = self.train_x.shape[1]\\n else:\\n degree = 1\\n\\n # Initialize the weight for linear model.\\n if initial_weight is not None:\\n self.weights.append(initial_weight)\\n else:\\n self.weights.append(np.random.rand(degree))\",\n \"def SGD(self, tr_d, va_d, epochs, lr, relz=\\\"\\\", lmbda=0.0, mu=0.0,perc=1.0):\\n print \\\"Training the network with SGD......\\\"\\n trlen = len(tr_d)\\n batch_size = 10\\n j = 0\\n accuracy = []\\n while j < epochs:\\n random.shuffle(tr_d)\\n batches = [tr_d[k:k+batch_size] for k in xrange(0,trlen,batch_size)]\\n for tr_batch in batches:\\n if(relz[0:2] != \\\"DP\\\"):\\n self.update_network(tr_batch,lr, relz, lmbda, mu)\\n else:\\n self.update_network_dp(tr_batch,lr,relz[2:], lmbda,perc, mu)\\n acy = self.Evaluate(va_d)\\n accuracy.append(acy)\\n if (va_d):\\n print \\\"Epoch {0}: {1}/{2}\\\".format(j, acy, len(va_d))\\n else:\\n print \\\"Epoch {0}:\\\".format(j)\\n j += 1\\n np.save(\\\"test_acy_%s_qinit_1.npy\\\"%(relz), accuracy)\",\n \"def train_perceptron(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> PerceptronClassifier:\\n raise Exception(\\\"Must be implemented\\\")\",\n \"def train_perceptron(train_exs: List[SentimentExample], feat_extractor: FeatureExtractor) -> PerceptronClassifier:\\n raise Exception(\\\"Must be implemented\\\")\",\n \"def fit(self, X, y_class, y_loc):\\n epochs = self.epochs\\n alpha = self.alpha\\n\\n tensor_X = torch.from_numpy(X)\\n t_y_class = torch.from_numpy(y_class)\\n t_y_class = t_y_class.float()\\n t_y_loc = torch.from_numpy(y_loc)\\n \\n learning_rate = 1e-3\\n optimizer = torch.optim.Adagrad(self.Net.parameters(), lr=learning_rate)\\n\\n for i in range(epochs): \\n out_1, out_2 = self.Net(tensor_X)\\n loss_1 = self.criterion_1(out_1, t_y_class)\\n loss_2 = self.criterion_2(out_2, t_y_loc)\\n loss = alpha * loss_1 + (1 - alpha) * loss_2\\n\\n optimizer.zero_grad()\\n loss.backward()\\n optimizer.step()\\n \\n params_dict = self.Net.state_dict()\\n w1 = params_dict['linear1.weight'].detach().numpy()\\n w1 = w1.T\\n b1 = params_dict['linear1.bias'].detach().numpy()\\n\\n w2 = params_dict['linear2.weight'].detach().numpy()\\n w2 = w2.T\\n b2 = params_dict['linear2.bias'].detach().numpy()\\n\\n w3 = params_dict['linear3_1.weight'].detach().numpy()\\n w3 = w3.T \\n b3 = params_dict['linear3_1.bias'].detach().numpy()\\n\\n w4 = params_dict['linear3_2.weight'].detach().numpy()\\n w4 = w4.T \\n b4 = params_dict['linear3_2.bias'].detach().numpy()\\n\\n w5 = params_dict['linear4_1.weight'].detach().numpy()\\n w5 = w5.T\\n b5 = params_dict['linear4_1.bias'].detach().numpy()\\n\\n w6 = params_dict['linear4_2.weight'].detach().numpy()\\n w6 = w6.T \\n b6 = params_dict['linear4_2.bias'].detach().numpy()\\n\\n self.set_model_params(w1, b1, w2, b2, w3, b3, w4, b4, w5, b5, w6, b6)\\n\\n return\",\n \"def trainNet():\",\n \"def gradient_descent(self, X ,eta, tol,iter):\\n gd=[]\\n gd_x=[X]\\n iteration=0\\n # current_pt=X\\n first_derivative=sym.diff(self.gdfunc)\\n #print(first_derivative)\\n x=sym.Symbol('x')\\n first_derivative=sym.lambdify(x,first_derivative)\\n learn_rate=eta\\n \\n \\n prev_x=X\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n #print(\\\"prev_x = \\\",prev_x,\\\" Next x = \\\",new_x)\\n for i in range(iter):\\n prev_x=new_x\\n #print(prev_x)\\n new_x=prev_x -(learn_rate*first_derivative(prev_x))\\n gd_x.append(new_x)\\n # print(\\\"x = \\\",new_x,\\\"Gradient =\\\",learn_rate*self.func(prev_x))\\n if abs(self.func(new_x)) <= self.func(tol) :\\n break\\n iteration=iteration+1\\n #print(\\\"Best at GD x= \\\",new_x)\\n gd.append(gd_x)\\n gd.append(new_x)\\n gd.append(iteration)\\n\\n return gd\",\n \"def train(network,X,y):\\r\\n \\r\\n # Get the layer activations\\r\\n layer_activations = forward(network,X)\\r\\n logits = layer_activations[-1]\\r\\n \\r\\n # Compute the loss and the initial gradient\\r\\n loss = softmax_crossentropy_with_logits(logits,y)\\r\\n loss_grad = grad_softmax_crossentropy_with_logits(logits,y)\\r\\n \\r\\n for i in range(1, len(network)):\\r\\n loss_grad = network[len(network) - i].backward(layer_activations[len(network) - i - 1], loss_grad)\\r\\n #loss_grad = network[0].backward(X, loss_grad)\\r\\n return np.mean(loss)\",\n \"def __trainLocal__(self, featureVals, targetVals):\\n pass\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n\\n cur_cost = float(\\\"inf\\\")\\n tolerance = 10 ** -6\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n while abs(new_cost - cur_cost) > tolerance:\\n cur_cost = new_cost\\n gradient = np.dot(np.transpose(Xless), np.subtract(np.dot(Xless, self.weights), y)) / numsamples #+ (2 * self.params['regwgt'] * self.weights)\\n step_size = self.line_search(self.weights, new_cost, gradient, Xless, y, self.params['regwgt'], numsamples)\\n self.weights = self.weights - (step_size * gradient)\\n new_cost = self.cost(self.weights, Xless, y, self.params['regwgt'], numsamples)\\n\\n #Format properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def train(self):\\n learning_rate = tf.train.exponential_decay(self.learning_rate, self.global_step, self.decay_steps,self.decay_rate, staircase=True)\\n self.learning_rate_=learning_rate\\n #noise_std_dev = tf.constant(0.3) / (tf.sqrt(tf.cast(tf.constant(1) + self.global_step, tf.float32))) #gradient_noise_scale=noise_std_dev\\n train_op = tf_contrib.layers.optimize_loss(self.loss_val, global_step=self.global_step,\\n learning_rate=learning_rate, optimizer=\\\"Adam\\\",clip_gradients=self.clip_gradients)\\n return train_op\",\n \"def fit(self, X, y, max_iter=MAX_ITER):\\n X = self.normalize_data(X)\\n X = self.add_bias(X)\\n n_tasks = len(X)\\n n_feats = X[0].shape[1]\\n W = np.random.randn(n_feats, n_tasks)\\n start = time.time()\\n cost_function = 0\\n for t in range(n_tasks):\\n #print('Training {} task with lasso regression'.format(t))\\n lasso = LogisticRegression(C=self.lambda_1,\\n penalty='l1',\\n max_iter=max_iter)\\n lasso.fit(X[t], y[t])\\n W[:, t] = lasso.coef_\\n stop = time.time() - start\\n self.W = W\\n return W, np.array([cost_function]), stop\",\n \"def stochastic_gradient_descent(X, y, max_niter=100):\\n m, n = X.shape\\n w = np.zeros((n, 1))\\n\\n for i in range(max_niter):\\n data_indices = list(range(m))\\n for j in range(m):\\n alpha = 4.0 / (i + j + 1.0) + 0.01\\n rand_idx = int(np.random.uniform(0, len(data_indices)))\\n h = sigmoid(np.dot(X[rand_idx, :], w))\\n error = h - float(y[rand_idx])\\n w = w - alpha * np.outer(X[rand_idx, :], error)\\n print('{0} iterations with error {1} weight {2} alpha={3}'.format(i, error, w, alpha))\\n del(data_indices[rand_idx])\\n classify.w = w\\n return w\",\n \"def train(self, training_steps=10):\",\n \"def gradient_model (self, x, initial_weights = None, \\\\\\n step_size = 5.0e-6, tol = 2.5e+7, n_iters = 501, l2 = 0):\\n # setup initial intercept, slope, iter number and rss\\n if initial_weights is None:\\n weights = self.initial_weight\\n else:\\n weights = initial_weights\\n # Compute indicator value for (y_i = +1)\\n indicators = np.array([int (i) for i in (self.train_output_y==1)])\\n for itr in range(n_iters):\\n # Predict P(y_i = +1|x_1,w) using your predict_probability() function\\n _, pred_probs = self.predict_probability(self.train_feature_x, weights)\\n \\n # Compute the errors as indicator - predictions\\n errors = indicators - pred_probs\\n\\n #Update the weights:\\n derivative = self.feature_derivative(errors, weights, l2)\\n weights = weights + derivative * (step_size) \\n \\n #check if converged\\n #todo\\n \\\"\\\"\\\"\\n # Checking whether log likelihood is increasing\\n if itr <= 15 or (itr <= 100 and itr % 10 == 0) or (itr <= 1000 and itr % 100 == 0) \\\\\\n or (itr <= 10000 and itr % 1000 == 0) or itr % 10000 == 0:\\n lp = self.compute_log_likelihood(indicators,weights)\\n print 'iteration %*d: log likelihood of observed labels = %.8f' % \\\\\\n (int(np.ceil(np.log10(n_iters))), itr, lp)\\n \\\"\\\"\\\"\\n \\n #check weights\\n #print \\\"\\\\n\\\"\\n #print \\\"The weights for features: \\\", weights\\n #final prediction\\n preds = self.prediction(x, weights)\\n return preds, weights\",\n \"def fit(self, x, y): \\n # *** START CODE HERE ***\\n y = y.reshape(y.shape[0], 1)\\n y_0 = (1 - y).reshape(y.shape)\\n m = y.shape[0]\\n m_0 = np.asscalar(np.sum(y_0))\\n m_1 = np.asscalar(np.sum(y))\\n # Find phi, mu_0, mu_1, and sigma\\n phi = np.sum(y) / m\\n mu_0 = (np.sum(np.multiply(y_0, x), axis = 0, keepdims = True) / m_0) #.reshape(y.shape)\\n mu_1 = np.sum(np.multiply(y, x), axis = 0, keepdims=True) / m_1\\n sigma = getsigma(x, mu_0, mu_1, m, y, y_0)\\n # Write theta in terms of the parameters\\n sigma_inv = np.linalg.inv(sigma)\\n log_phi = np.log(np.exp(-1 * np.log(phi)) - 1)\\n theta_0 = (np.dot(np.dot(mu_0, sigma_inv), mu_0.T) - np.dot(np.dot(mu_1, sigma_inv), mu_1.T)) / 2 - log_phi\\n self.theta = np.concatenate((theta_0, np.dot(sigma_inv, (mu_1 - mu_0).T)))\\n # Compute cost\\n x_0 = np.zeros((x.shape[0], 1)) + 1\\n x_train = np.concatenate((x_0.T, x.T))\\n h_theta = sigmoid(np.dot(self.theta.T, x_train)).T\\n cost = - np.sum(np.dot(y.T, np.log(h_theta - (h_theta - 0.5) * self.eps)) + (np.dot(y_0.T, np.log(1 - h_theta + (h_theta - 0.5) * self.eps)))) / m\\n if self.verbose:\\n print(\\\"Cost: \\\" + str(cost))\\n # *** END CODE HERE ***\",\n \"def train():\\n\\n ### DO NOT CHANGE SEEDS!\\n # Set the random seeds for reproducibility\\n np.random.seed(42)\\n\\n ## Prepare all functions\\n # Get number of units in each hidden layer specified in the string such as 100,100\\n if FLAGS.dnn_hidden_units:\\n dnn_hidden_units = FLAGS.dnn_hidden_units.split(\\\",\\\")\\n dnn_hidden_units = [int(dnn_hidden_unit_) for dnn_hidden_unit_ in dnn_hidden_units]\\n else:\\n dnn_hidden_units = []\\n\\n # Get negative slope parameter for LeakyReLU\\n neg_slope = FLAGS.neg_slope\\n\\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n import matplotlib.pyplot as plt\\n\\n data = cifar10_utils.get_cifar10(FLAGS.data_dir)\\n train = data['train']\\n test = data['test']\\n dim_x = train.images.shape[1]*train.images.shape[2]*train.images.shape[3]\\n\\n mlp = MLP(dim_x, dnn_hidden_units, train.labels.shape[1], neg_slope)\\n loss_module = CrossEntropyModule()\\n\\n loss_train = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n loss_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n accuracy_test = np.zeros((int(np.floor(FLAGS.max_steps/FLAGS.eval_freq), )))\\n\\n images_test = test.images\\n labels_test = test.labels\\n images_test = np.reshape(images_test, (images_test.shape[0], dim_x))\\n\\n for i in range(0, FLAGS.max_steps):\\n if PRINTS:\\n print('iter', i+1, end='\\\\r')\\n images, labels = train.next_batch(FLAGS.batch_size) \\n images = np.reshape(images, (images.shape[0], dim_x))\\n\\n pred = mlp.forward(images)\\n loss = loss_module.forward(pred, labels)\\n loss_grad = loss_module.backward(pred, labels)\\n mlp.backward(loss_grad)\\n\\n for module in reversed(mlp.modules):\\n if isinstance(module, LinearModule):\\n module.params['weight'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['weight']\\n module.params['bias'] -= 1/FLAGS.batch_size*FLAGS.learning_rate*module.grads['bias']\\n if (i+1) % FLAGS.eval_freq == 0:\\n pred_test = mlp.forward(images_test)\\n loss_train[i // FLAGS.eval_freq] = loss\\n accuracy_test[i // FLAGS.eval_freq] = accuracy(pred_test, labels_test)\\n loss_test[i // FLAGS.eval_freq] = loss_module.forward(pred_test, labels_test)\\n if PRINTS:\\n print()\\n print('test_loss:', loss_test[i // FLAGS.eval_freq])\\n print('test_accuracy:', accuracy_test[i // FLAGS.eval_freq])\\n print('train_loss:', loss_train[i // FLAGS.eval_freq])\\n\\n if PLOTS:\\n fig, ax = plt.subplots(1, 2, figsize=(10,5))\\n fig.suptitle('Training curves for Numpy MLP\\\\nFinal test accuracy: {:0.4f}, default configuration'.format(accuracy_test[i // FLAGS.eval_freq]))\\n\\n ax[0].set_title('Loss')\\n ax[0].set_ylabel('Loss value')\\n ax[0].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[0].plot(loss_train, label='Train')\\n ax[0].plot(loss_test, label='Test')\\n ax[0].legend()\\n\\n ax[1].set_title('Accuracy')\\n ax[1].set_ylabel('Accuracy value')\\n ax[1].set_xlabel('No of batches seen x{}'.format(FLAGS.eval_freq))\\n ax[1].plot(accuracy_test, label='Test')\\n ax[1].legend()\\n plt.show()\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def train(self, verbose=True):\\n\\n\\n learned = False\\n iteration = 0\\n\\n from util.loss_functions import DifferentError\\n loss = DifferentError()\\n\\n\\n\\n\\n\\n # Train for some epochs if the error is not 0\\n while not learned:\\n # x ist ein Bild bestehend aus einem Label (erster Eintrag) und 784 Pixeln\\n # t ist das Zielergebnis von x (überprüfbar mit dem Label)\\n # o ist der tatsächliche Ergebnis von x\\n # w ist der Gewichtsvektor\\n # Als Aktivierungsfunktion verwenden wir die Sigmoid Funktion\\n # Das Training wird dann beendet, sobald das Fehlerkriterium konvergiert\\n\\n totalError = 0\\n\\n output = []\\n labels = self.trainingSet.label\\n inputs = self.trainingSet.input\\n\\n # iteriere für jede Instanz im Trainingsset x € X\\n for input in inputs:\\n # Ermittle O_x = sig(w*x)\\n output.append(self.fire(input))\\n\\n # Ermittle Fehler AE = tx - ox\\n error = loss.calculateError(np.array(labels), np.array(output))\\n\\n # grad = [0]\\n grad = np.zeros(len(self.trainingSet.input[0]))\\n grad2 = np.zeros(len(self.trainingSet.input[0]))\\n\\n for e, input, out in zip(error, inputs, output):\\n activationPrime = Activation.getDerivative(activationName)(np.dot(np.array(input), self.weight))\\n #grad += np.multiply( np.multiply( input, e), activationPrime)\\n grad += np.multiply( input, e)\\n\\n # Update grad = grad + errorPrime * x * activationPrime\\n\\n\\n\\n # print grad - grad2\\n #print \\\"Error: \\\" + str(error) + \\\" Grad: \\\" + str(grad)\\n\\n # update w: w <- w + n*grad\\n self.updateWeights(grad)\\n\\n\\n iteration += 1\\n totalError = error.sum()\\n\\n if verbose:\\n logging.info(\\\"Epoch: %i; Error: %i\\\", iteration, totalError)\\n\\n if abs(totalError) < 0.01 or iteration >= self.epochs:\\n # stop criteria is reached\\n learned = True\\n\\n pass\",\n \"def train_classifier(train_data, dev_data, num_iterations, learning_rate, params):\\n for I in range(num_iterations):\\n cum_loss = 0.0 # total loss in this iteration.\\n random.shuffle(train_data)\\n for label, features in train_data:\\n x = feats_to_vec(features) # convert features to a vector.\\n y = L2I[label] # convert the label to number if needed.\\n loss, grads = ll.loss_and_gradients(x, y, params)\\n cum_loss += loss\\n # update weights and bias\\n params = [params[i] - learning_rate * grads[i] for i in range(len(grads))]\\n train_loss = cum_loss / len(train_data)\\n train_accuracy = accuracy_on_dataset(train_data, params)\\n dev_accuracy = accuracy_on_dataset(dev_data, params)\\n print(I, train_loss, train_accuracy, dev_accuracy)\\n return params\",\n \"def SGD(self, X_train, Y_train, X_validation, Y_validation, epochs, mini_batch_size, learning_rate, decay):\\n \\n training_data = zip(X_train, Y_train)\\n validation_data = zip(X_validation, Y_validation)\\n\\n \\n \\\"\\\"\\\"Take the training data and make a list out of it\\\"\\\"\\\"\\n training_data = list(training_data)\\n \\n \\\"\\\"\\\"Check if there is data in the test_data\\\"\\\"\\\"\\n if validation_data:\\n validation_data = list(validation_data)\\n n_validation_data = len(validation_data)\\n \\n \\\"\\\"\\\"\\n Mini-batches: Each mini-batch contains mini_batch_size elements from the training set.\\n \\n Splits the training data into mini-bachtes, and for each mini-batches we train the network. \\n \\n \\\"\\\"\\\" \\n\\n# Updated for the testing\\n# ========================\\n mini_batches = []\\n high_score = [0,0]\\n for j in range(epochs):\\n random.shuffle(training_data)\\n for k in range(0, len(training_data), mini_batch_size):\\n mini_batches.append(training_data[k:k+mini_batch_size])\\n for mini_batch in mini_batches:\\n self.update_mini_batch(mini_batch, learning_rate)\\n if validation_data:\\n new_score = self.evaluate(X_validation, Y_validation)\\n if high_score[0] < new_score:\\n high_score[0] = new_score\\n high_score[1] = j + 1\\n learning_rate = learning_rate * (1-decay)\\n \\n return high_score[0], high_score[1]\\n# ========================\\n\\n\\n \\\"\\\"\\\"\\n Update the network's weights and biases by applying\\n gradient descent using backpropagation to a single mini batch.\\n The ``mini_batch`` is a list of tuples ``(x, y)``, and ``eta``\\n is the learning rate.\\\"\\\"\\\"\",\n \"def gradient_descent(g_dd, y_train, loss, g_td=None):\\n\\n output_dimension = y_train.shape[-1]\\n\\n g_dd = empirical.flatten_features(g_dd)\\n\\n def fl(fx):\\n \\\"\\\"\\\"Flatten outputs.\\\"\\\"\\\"\\n return np.reshape(fx, (-1,))\\n\\n def ufl(fx):\\n \\\"\\\"\\\"Unflatten outputs.\\\"\\\"\\\"\\n return np.reshape(fx, (-1, output_dimension))\\n\\n # These functions are used inside the integrator only if the kernel is\\n # diagonal over the logits.\\n ifl = lambda x: x\\n iufl = lambda x: x\\n\\n # Check to see whether the kernel has a logit dimension.\\n if y_train.size > g_dd.shape[-1]:\\n out_dim, ragged = divmod(y_train.size, g_dd.shape[-1])\\n if ragged or out_dim != y_train.shape[-1]:\\n raise ValueError()\\n ifl = fl\\n iufl = ufl\\n\\n y_train = np.reshape(y_train, (-1))\\n grad_loss = grad(functools.partial(loss, y_hat=y_train))\\n\\n if g_td is None:\\n dfx_dt = lambda unused_t, fx: -ifl(np.dot(g_dd, iufl(grad_loss(fx))))\\n\\n def predict(dt, fx=0.):\\n r = ode(dfx_dt).set_integrator('dopri5')\\n r.set_initial_value(fl(fx), 0)\\n r.integrate(dt)\\n\\n return ufl(r.y)\\n else:\\n g_td = empirical.flatten_features(g_td)\\n\\n def dfx_dt(unused_t, fx, train_size):\\n fx_train = fx[:train_size]\\n dfx_train = -ifl(np.dot(g_dd, iufl(grad_loss(fx_train))))\\n dfx_test = -ifl(np.dot(g_td, iufl(grad_loss(fx_train))))\\n return np.concatenate((dfx_train, dfx_test), axis=0)\\n\\n def predict(dt, fx_train=0., fx_test=0.):\\n r = ode(dfx_dt).set_integrator('dopri5')\\n\\n fx = fl(np.concatenate((fx_train, fx_test), axis=0))\\n train_size, output_dim = fx_train.shape\\n r.set_initial_value(fx, 0).set_f_params(train_size * output_dim)\\n r.integrate(dt)\\n fx = ufl(r.y)\\n\\n return fx[:train_size], fx[train_size:]\\n\\n return predict\",\n \"def learn(self, Xtrain, ytrain):\\n self.cost_data = []\\n self.weights = np.zeros((len(self.params['features']), 1))\\n numsamples = Xtrain.shape[0]\\n Xless = Xtrain[:,self.params['features']]\\n y = ytrain[:, np.newaxis]\\n epochs = 1000\\n\\n for epoch in range(epochs):\\n #Shuffle the data, making sure to maintain the proper correspondence between the features and targets\\n data_set = np.append(Xless, y, axis=1)\\n np.random.shuffle(data_set)\\n Xless = data_set[:, 0:data_set.shape[1] - 1]\\n y = data_set[:, -1, np.newaxis]\\n for t in range(numsamples):\\n gradient = np.dot(np.transpose(Xless[t, :][np.newaxis, :]), np.subtract(np.dot(Xless[t, :], self.weights), y[t, np.newaxis]))\\n step_size = 0.01 / (epoch + 1)\\n self.weights = self.weights - (step_size * gradient)\\n cur_cost = self.cost(self.weights, Xless[t, :], y[t])\\n #Format the array properly for the error function\\n self.weights = np.ndarray.flatten(self.weights)\",\n \"def fast_loss_and_grad(self, X, y):\\n loss = 0.0\\n grad = np.zeros(self.W.shape) # initialize the gradient as zero\\n \\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the softmax loss and gradient WITHOUT any for loops.\\n # ================================================================ #\\n \\n num_train = X.shape[0]\\n num_classes = self.W.shape[0]\\n \\n# # vectorized loss calculation #\\n class_scores_matrix = np.dot(self.W,X.T) # calculating class scores matrix (C x m): rows are class scores transposes\\n class_scores_matrix -= np.max(class_scores_matrix) # considering the possible issue for numerical instability and account for it\\n exp_a = np.exp(class_scores_matrix) # calculating the exponents\\n \\n# y_exp = np.array(exp_a[y, np.arange(0, class_scores_matrix.shape[1])])\\n# #print(exp_a[:,:3])\\n# #print(y[:3])\\n# #print(y_exp[:3])\\n \\n# tt = np.sum(exp_a,axis=0)\\n# tt2 = np.divide(tt,y_exp)\\n# print(num_train)\\n# tt3 = np.power(tt2,1/num_train)\\n# loss = np.log(np.prod(tt3))\\n \\n \\n \\n \\n (C, D) = self.W.shape\\n N = X.shape[0]\\n\\n scores = np.dot(self.W, X.T)\\n scores -= np.max(scores) # shift by log C to avoid numerical instability\\n\\n y_mat = np.zeros(shape = (C, N))\\n y_mat[y, range(N)] = 1\\n\\n # matrix of all zeros except for a single wx + log C value in each column that corresponds to the\\n # quantity we need to subtract from each row of scores\\n correct_wx = np.multiply(y_mat, scores)\\n\\n # create a single row of the correct wx_y + log C values for each data point\\n sums_wy = np.sum(correct_wx, axis=0) # sum over each column\\n\\n exp_scores = np.exp(scores)\\n sums_exp = np.sum(exp_scores, axis=0) # sum over each column\\n result = np.log(sums_exp)\\n\\n result -= sums_wy\\n\\n loss = np.sum(result)\\n loss /= num_train\\n \\n \\n # vectorized gradient calculation #\\n exp_a_sum = np.sum(exp_a,axis=0)\\n\\n y_mat_corres = np.zeros(shape = (num_classes, num_train))\\n y_mat_corres[y, range(num_train)] = 1\\n sum_exp_scores = np.sum(exp_a, axis=0) \\n sum_exp_scores = 1.0 / exp_a_sum # division by sum over columns\\n exp_a *= sum_exp_scores\\n grad = np.dot(exp_a, X)\\n grad -= np.dot(y_mat_corres, X)\\n grad /= num_train\\n \\n\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss, grad\",\n \"def _train(self, loss):\\n config = ConfigParser.ConfigParser()\\n config.read(\\\"config/conf.cfg\\\")\\n\\n learning_rate =float(config.get(\\\"Common Params\\\", \\\"learning_rate\\\"))\\n moment = float(config.get(\\\"Common Params\\\", \\\"moment\\\"))\\n opt = tf.train.AdamOptimizer()\\n train_step = opt.minimize(loss)\\n return train_step\\n\\n # grads = opt.compute_gradients(self.total_loss)\\n\\n # apply_gradient_op = opt.apply_gradients(grads, global_step=self.global_step)\\n\\n #return apply_gradient_op\",\n \"def train(self, X, y, learning_rate=1e-3, reg=1e-5, num_iters=100,\\n batch_size=200, verbose=False):\\n num_train, dim = X.shape\\n num_classes = np.max(y) + 1 # assume y takes values 0...K-1 where K is number of classes\\n if self.W is None:\\n # lazily initialize W\\n self.W = 0.001 * np.random.randn(dim, num_classes)\\n\\n # Run stochastic gradient descent to optimize W\\n loss_history = []\\n for it in range(num_iters):\\n X_batch = None\\n y_batch = None\\n\\n #########################################################################\\n # TODO: #\\n # Sample batch_size elements from the training data and their #\\n # corresponding labels to use in this round of gradient descent. #\\n # Store the data in X_batch and their corresponding labels in #\\n # y_batch; after sampling X_batch should have shape (batch_size, dim) #\\n # and y_batch should have shape (batch_size,) #\\n # #\\n # Hint: Use np.random.choice to generate indices. Sampling with #\\n # replacement is faster than sampling without replacement. #\\n #########################################################################\\n choices = np.random.choice(num_train, batch_size)\\n X_batch = X[choices]\\n y_batch = y[choices]\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n # evaluate loss and gradient\\n loss, grad = self.loss(X_batch, y_batch, reg)\\n loss_history.append(loss)\\n\\n # perform parameter update\\n #########################################################################\\n # TODO: #\\n # Update the weights using the gradient and the learning rate. #\\n #########################################################################\\n self.W -= learning_rate * grad\\n #########################################################################\\n # END OF YOUR CODE #\\n #########################################################################\\n\\n if verbose and it % 100 == 0:\\n print('iteration %d / %d: loss %f' % (it, num_iters, loss))\\n\\n return loss_history\",\n \"def mylinearsvm(lambdat, eta_init, maxiter, X, y):\\n d = np.size(X, 1)\\n beta_init = np.zeros(d)\\n theta_init = np.zeros(d)\\n betas, objs = fast_grad(beta_init, theta_init, lambdat, eta_init, maxiter,X=X,y=y)\\n return betas, objs\",\n \"def train(self, features, labels, optimizer, loss_scale=None):\\n loss, gradients = self.compute_gradients(\\n features,\\n labels,\\n optimizer,\\n loss_scale=loss_scale,\\n )\\n optimizer.apply_gradients(list(zip(gradients, self.trainable_weights)))\\n return loss\",\n \"def fit(self, X_train, Y_train, X_unlabeled, I_train=None):\\n\\n logger.info('Fitting semi-supervised classifier ...')\\n\\n start = time.time()\\n\\n # Creating a subgraph\\n self.subgraph = Subgraph(X_train, Y_train, I_train)\\n\\n # Finding prototypes\\n self._find_prototypes()\\n\\n # Gather current number of nodes\\n current_n_nodes = self.subgraph.n_nodes\\n\\n for i, feature in enumerate(X_unlabeled):\\n node = Node(current_n_nodes + i, 0, feature)\\n\\n self.subgraph.nodes.append(node)\\n\\n # Creating a minimum heap\\n h = Heap(size=self.subgraph.n_nodes)\\n\\n for i in range(self.subgraph.n_nodes):\\n if self.subgraph.nodes[i].status == c.PROTOTYPE:\\n # If yes, it does not have predecessor nodes\\n self.subgraph.nodes[i].pred = c.NIL\\n\\n # Its predicted label is the same as its true label\\n self.subgraph.nodes[i].predicted_label = self.subgraph.nodes[i].label\\n\\n # Its cost equals to zero\\n h.cost[i] = 0\\n\\n # Inserts the node into the heap\\n h.insert(i)\\n\\n else:\\n # Its cost equals to maximum possible value\\n h.cost[i] = c.FLOAT_MAX\\n\\n while not h.is_empty():\\n # Removes a node\\n p = h.remove()\\n\\n # Appends its index to the ordered list\\n self.subgraph.idx_nodes.append(p)\\n\\n # Gathers its cost\\n self.subgraph.nodes[p].cost = h.cost[p]\\n\\n for q in range(self.subgraph.n_nodes):\\n if p != q:\\n if h.cost[p] < h.cost[q]:\\n if self.pre_computed_distance:\\n weight = self.pre_distances[self.subgraph.nodes[p]\\n .idx][self.subgraph.nodes[q].idx]\\n\\n else:\\n weight = self.distance_fn(self.subgraph.nodes[p].features, self.subgraph.nodes[q].features)\\n\\n # The current cost will be the maximum cost between the node's and its weight (arc)\\n current_cost = np.maximum(h.cost[p], weight)\\n\\n if current_cost < h.cost[q]:\\n # `q` node has `p` as its predecessor\\n self.subgraph.nodes[q].pred = p\\n\\n # And its predicted label is the same as `p`\\n self.subgraph.nodes[q].predicted_label = self.subgraph.nodes[p].predicted_label\\n\\n # As we may have unlabeled nodes, make sure that `q` label equals to `q` predicted label\\n self.subgraph.nodes[q].label = self.subgraph.nodes[q].predicted_label\\n\\n # Updates the heap `q` node and the current cost\\n h.update(q, current_cost)\\n\\n # The subgraph has been properly trained\\n self.subgraph.trained = True\\n\\n end = time.time()\\n\\n train_time = end - start\\n\\n logger.info('Semi-supervised classifier has been fitted.')\\n logger.info('Training time: %s seconds.', train_time)\",\n \"def fit(self, x, y):\\n # *** START CODE HERE ***\\n num_examples = x.shape[0]\\n num_features = x.shape[1]\\n iteration = 1\\n if self.theta == None:\\n self.theta = np.zeros((num_features,))\\n while iteration <= self.max_iter:\\n h_theta = np.dot(x, self.theta)\\n g_theta = self.sigmoid(h_theta)\\n J_cost = -np.mean(y*np.log(g_theta) + (1 - y)*np.log(1 - g_theta))\\n H = 1/num_examples*(np.dot(np.transpose(g_theta*(1-g_theta))*np.transpose(x), x))\\n J_prime = - 1/num_examples*np.dot(np.transpose(y - g_theta), x)\\n d_theta = - np.linalg.solve(H, J_prime)\\n self.theta += d_theta\\n if np.linalg.norm(d_theta, 1) < self.eps:\\n break\\n if self.verbose:\\n print(\\\"Loss value: \\\", J_cost)\\n iteration += 1\\n # *** END CODE HERE ***\",\n \"def _batch_gradient_descent(self, X, y, lr, epochs):\\n\\n # Initialize the bias and weights.\\n _, n = X.shape\\n self.bias = 0\\n self.weights = np.random.normal(size=n)\\n\\n for i in range(epochs):\\n # Calculate and sum the gradient delta of each sample\\n grad_bias, grad_weights = self._get_gradient(X, y)\\n\\n # Show the gradient of each epoch.\\n grad = (grad_bias + grad_weights.mean()) / 2\\n print(\\\"Epochs %d gradient %.3f\\\" % (i + 1, grad), flush=True)\\n\\n # Update the bias and weight by gradient of current epoch\\n self.bias += lr * grad_bias\\n self.weights += lr * grad_weights\",\n \"def fit(self, X):\",\n \"def fit(self, X, y, X_validate, y_validate):\\n \\n iterate = 800\\n \\n self.SGD_theta_list = [0]*len(X[0])\\n self.SGD_bias = 0\\n\\n SGD_cost_history = []\\n SGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1) #selecting one random row for SGD\\n temp_X = []\\n temp_X.append(X[selection])\\n temp_y = []\\n temp_y.append(y[selection])\\n self.SGD_bias, self.SGD_theta_list = self.update_thetas(np.array(temp_X), np.array(temp_y), self.SGD_theta_list, self.SGD_bias,self.training_rate)\\n SGD_cost = self.cost_function(X, y, self.SGD_theta_list, self.SGD_bias)\\n SGD_cost_history.append(SGD_cost)\\n SGD_validate_cost = self.cost_function(X_validate, y_validate,self.SGD_theta_list, self.SGD_bias)\\n SGD_validate_cost_history.append(SGD_validate_cost)\\n\\n self.FINAL_SGD_TRAIN_LOSS.append(SGD_cost_history[-1])\\n self.FINAL_SGD_VALIDATE_LOSS.append(SGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), SGD_cost_history)\\n plt.plot(list(range(iterate)), SGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss SGD\\\")\\n plt.show()\\n \\n \\n self.BGD_theta_list = [0]*len(X[0])\\n self.BGD_bias = 0\\n\\n BGD_cost_history = []\\n BGD_validate_cost_history = []\\n\\n for i in range(iterate):\\n if(i%100==0):\\n print(i,\\\" iterations\\\")\\n selection = random.randint(0, len(X)-1)\\n \\n self.BGD_bias, self.BGD_theta_list = self.update_thetas(X, y, self.BGD_theta_list, self.BGD_bias,self.training_rate)\\n\\n BGD_cost = self.cost_function(X, y, self.BGD_theta_list, self.BGD_bias)\\n BGD_cost_history.append(BGD_cost)\\n BGD_validate_cost = self.cost_function(X_validate, y_validate,self.BGD_theta_list, self.BGD_bias)\\n BGD_validate_cost_history.append(BGD_validate_cost)\\n\\n self.FINAL_BGD_TRAIN_LOSS.append(BGD_cost_history[-1])\\n self.FINAL_BGD_VALIDATE_LOSS.append(BGD_validate_cost_history[-1])\\n\\n plt.plot(list(range(iterate)), BGD_cost_history)\\n plt.plot(list(range(iterate)), BGD_validate_cost_history)\\n plt.xlabel(\\\"Iterations\\\")\\n plt.ylabel(\\\"Loss BGD\\\")\\n plt.show()\\n\\n print(\\\"FINAL_SGD_TRAIN_LOSS\\\\n\\\",self.FINAL_SGD_TRAIN_LOSS)\\n print(\\\"FINAL_SGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_SGD_VALIDATE_LOSS)\\n print(\\\"FINAL_BGD_TRAIN_LOSS\\\\n\\\",self.FINAL_BGD_TRAIN_LOSS)\\n print(\\\"FINAL_BGD_VALIDATE_LOSS\\\\n\\\",self.FINAL_BGD_VALIDATE_LOSS)\\n\\n \\n return self\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7036311","0.6894752","0.6888206","0.6804692","0.6742188","0.6733776","0.6727004","0.67164975","0.6693492","0.666076","0.6657247","0.66092634","0.65603244","0.6525685","0.6510231","0.6499339","0.64880437","0.6471506","0.64697635","0.64687717","0.6464059","0.64604646","0.6451858","0.6444873","0.6443857","0.64353025","0.64305055","0.64254844","0.6405261","0.63803566","0.63774866","0.636945","0.6363075","0.6356727","0.63530743","0.63472766","0.63399744","0.6328838","0.6328257","0.63268507","0.63192946","0.63176686","0.6312781","0.6304476","0.62990814","0.6298741","0.6298542","0.6294062","0.6294062","0.62930036","0.628982","0.6288345","0.62809885","0.62743133","0.62709546","0.6262969","0.6259242","0.6257678","0.6255769","0.6254159","0.6242943","0.6233052","0.6232821","0.6219656","0.6215189","0.62121224","0.6210555","0.6204171","0.620175","0.61943215","0.6190945","0.61890686","0.61890686","0.6185396","0.6182991","0.61773866","0.6170329","0.6162126","0.61617273","0.61595416","0.6155054","0.6153536","0.6153214","0.6152037","0.61499184","0.614685","0.614658","0.6144473","0.6144267","0.6138425","0.6137987","0.613719","0.613378","0.6128621","0.6127314","0.61248493","0.6121242","0.6117761","0.61164284","0.6113564","0.6111736"],"string":"[\n \"0.7036311\",\n \"0.6894752\",\n \"0.6888206\",\n \"0.6804692\",\n \"0.6742188\",\n \"0.6733776\",\n \"0.6727004\",\n \"0.67164975\",\n \"0.6693492\",\n \"0.666076\",\n \"0.6657247\",\n \"0.66092634\",\n \"0.65603244\",\n \"0.6525685\",\n \"0.6510231\",\n \"0.6499339\",\n \"0.64880437\",\n \"0.6471506\",\n \"0.64697635\",\n \"0.64687717\",\n \"0.6464059\",\n \"0.64604646\",\n \"0.6451858\",\n \"0.6444873\",\n \"0.6443857\",\n \"0.64353025\",\n \"0.64305055\",\n \"0.64254844\",\n \"0.6405261\",\n \"0.63803566\",\n \"0.63774866\",\n \"0.636945\",\n \"0.6363075\",\n \"0.6356727\",\n \"0.63530743\",\n \"0.63472766\",\n \"0.63399744\",\n \"0.6328838\",\n \"0.6328257\",\n \"0.63268507\",\n \"0.63192946\",\n \"0.63176686\",\n \"0.6312781\",\n \"0.6304476\",\n \"0.62990814\",\n \"0.6298741\",\n \"0.6298542\",\n \"0.6294062\",\n \"0.6294062\",\n \"0.62930036\",\n \"0.628982\",\n \"0.6288345\",\n \"0.62809885\",\n \"0.62743133\",\n \"0.62709546\",\n \"0.6262969\",\n \"0.6259242\",\n \"0.6257678\",\n \"0.6255769\",\n \"0.6254159\",\n \"0.6242943\",\n \"0.6233052\",\n \"0.6232821\",\n \"0.6219656\",\n \"0.6215189\",\n \"0.62121224\",\n \"0.6210555\",\n \"0.6204171\",\n \"0.620175\",\n \"0.61943215\",\n \"0.6190945\",\n \"0.61890686\",\n \"0.61890686\",\n \"0.6185396\",\n \"0.6182991\",\n \"0.61773866\",\n \"0.6170329\",\n \"0.6162126\",\n \"0.61617273\",\n \"0.61595416\",\n \"0.6155054\",\n \"0.6153536\",\n \"0.6153214\",\n \"0.6152037\",\n \"0.61499184\",\n \"0.614685\",\n \"0.614658\",\n \"0.6144473\",\n \"0.6144267\",\n \"0.6138425\",\n \"0.6137987\",\n \"0.613719\",\n \"0.613378\",\n \"0.6128621\",\n \"0.6127314\",\n \"0.61248493\",\n \"0.6121242\",\n \"0.6117761\",\n \"0.61164284\",\n \"0.6113564\",\n \"0.6111736\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20190,"cells":{"query":{"kind":"string","value":"predict labels for test set by using the training weight"},"document":{"kind":"string","value":"def predict(self, X):\r\n y_pred = np.zeros(X.shape[1])\r\n y_pred = np.argmax(X.dot(self.W), axis = 1)\r\n \r\n return y_pred"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def predict(test_dataset,test_tX,weights):\n for idx, dataset in enumerate(test_tX):\n test_dataset[idx]['Prediction'] = predict_labels(weights[idx],dataset)\n return test_dataset","def predictTest(k, train, test):\r\n\r\n pred_labels = []\r\n\r\n # for each instance in the testing dataset, calculate all L2 distance from all training instances\r\n for te in range(len(test)):\r\n all_D = np.zeros((len(train), 1))\r\n\r\n # calculate the L2 distance of the testing instance from each training instance\r\n for tr in range(len(train)):\r\n D = 0\r\n for var in range(len(train.columns)-1):\r\n # if feature is real-valued, add (testing value - training value)^2\r\n if train[var].dtype == np.float64 or train[var].dtype == np.int64:\r\n D += (test[var][te] - train[var][tr])**2\r\n # if feature is nominal, add 1 if testing and training values are different\r\n else:\r\n if test[var][te] != train[var][tr]:\r\n D += 1\r\n all_D[tr] = D**(1/2)\r\n\r\n # sort all L2 distances, select K closest neighbors, and choose the most prevalent label\r\n all_D = np.column_stack((all_D, np.array(range(len(train)))))\r\n all_D = all_D[np.argsort(all_D[:, 0])]\r\n prob_labels = train[len(train.columns)-1][all_D[0:k, 1]].as_matrix()\r\n pred_labels.append(Counter(prob_labels).most_common(1)[0][0])\r\n\r\n return pred_labels","def predict(self, testing_set):\r\n # Run prediction by multiply inputs with the weight and map it\r\n # Through the activation function\r\n final_prob = 0\r\n probability = self.activation(self.weighted_sum(testing_set))\r\n prediction = self.threshold(probability)\r\n if prediction == 1:\r\n final_prob = probability\r\n else:\r\n final_prob = 1 - probability\r\n return [prediction, final_prob]","def predict_and_test(weight, test_data, test_label, regression= \"logistic\"):\n pred_test, _ = get_output(weight, test_data, regression= regression)\n acc = get_accuracy(pred_test, test_label, regression= regression)\n return acc, pred_test","def predict_labels(weights, data):\n y_pred = np.dot(data, weights)\n y_pred[np.where(y_pred <= 0)] = -1\n y_pred[np.where(y_pred > 0)] = 1\n \n return y_pred","def predict_labels(weights, data):\n y_pred = np.dot(data, weights)\n y_pred[np.where(y_pred <= 0)] = -1\n y_pred[np.where(y_pred > 0)] = 1\n \n return y_pred","def predict_labels(weights, data):\n y_pred = np.dot(data, weights)\n y_pred[np.where(y_pred <= 0)] = -1\n y_pred[np.where(y_pred > 0)] = 1\n \n return y_pred","def predict(self, Xtest):\n ytest = np.dot(Xtest, self.weights)\n return ytest","def predict(self, testData=[]):\n result = []\n for classValue in self._classAttrs:\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\n result.append(self._computeCondProb(testData, classValue))\n return self._classLabelMap[result.index(max(result))]","def predict(self, params, test):\n vect_logit = np.vectorize(logit)\n vect_comp = np.vectorize(complement)\n n_test = np.shape(test)[0]\n prior = self.model_prior\n conditional = self.model_conditional\n K = len(prior)\n p = np.shape(conditional)[1]\n test_p = np.shape(test)[1]\n if p != test_p:\n print \"Error: Number of training and testing features differ\"\n return\n preds = []\n weight = vect_logit(conditional)\n # Stores weight matrix\n condition_comp = vect_comp(conditional)\n intercept = np.log(\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\n # Stores intercept vector\n weight = weight.transpose()\n classifier = test.dot(weight) + intercept\n preds = np.argmax(classifier, axis=1) + 1\n # Add 1 because the classes have a 1-based index\n preds = preds.reshape(n_test, 1)\n return preds","def predict_labels(model, x_test):\n \n pred = model.predict(x_test)\n #pred_labels = model.predict_classes(x_test) # depricated\n pred_labels = np.argmax(model.predict(x_test), axis=-1)\n \n return pred, pred_labels","def predict(self):\n self.get_test_data()\n predicted_labels = []\n for row in self.test_data:\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\n return predicted_labels","def predict(self, example):\n label = \"\"\n pred = -99.0\n for w in self.weights:\n current = np.asarray(example.fvector)\n i = self.weights[w] @ current\n if i > pred:\n pred = i\n label = w\n return label","def predict(self):\n add = np.ones(len(self.X_test))\n X_add = np.c_[add, self.X_test]\n pred = np.dot(X_add, self.w_result.T)\n\n pred[pred > 0] = 1\n pred[pred < 0] = 0\n return pred","def test_predict(self):\n\n classifier = BertCCAMClassifier()\n classifier.load_model(\"models\")\n prediction = classifier.predict([\"bartosz\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}])\n\n # with multiple labels\n prediction = classifier.predict([\"ala bert\"])\n self.assertEqual(prediction, [{\"labels\": (\"A\", \"B\")}])\n\n # in a batch\n prediction = classifier.predict([\"bartosz\", \"adam\"])\n self.assertEqual(prediction, [{\"labels\": (\"B\",)}, {\"labels\": (\"A\",)}])","def predict(self, test_set, test_labels):\n\n with tf.Session() as self.tf_session:\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})","def predict(self, X_test):\n\n # Predict Label 0\n i = 0\n X = X_test\n\n # Retrieve trained classifier for label 0\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n result = np.zeros((X_test.shape[0], self.label_dim))\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n # iterator = tqdm.trange(1, self.label_dim)\n iterator = range(1, self.label_dim)\n for i in iterator:\n # Predict Label i\n\n # Retrieve trained classifier for label i\n clf = self.trained[i]\n\n # Make prediction\n y = clf.predict(X)\n\n result[:, i] = y\n\n # Concatenate result to X\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\"csr\")\n\n return result","def test(self, test_instances, test_labels):\n scores = self.classifier.predict(test_instances)\n # TODO: print report","def predict(self, test_vectors):\n # Calculate the best matching label for each node\n if not self.ready_for_prediction:\n # totals = sum((node.labels for node in self.codebook), Counter())\n for node in self.codebook:\n # Remove unlabeled hits\n try:\n node.labels.pop(None)\n except KeyError:\n pass\n # # Take into account small clusters. A frequency approach\n # freq_counter = Counter({label: count / totals[label]\n # for label, count in node.labels.items()})\n # if len(freq_counter) > 0:\n # node.label = freq_counter.most_common(1)[0][0]\n # else:\n # node.label = ''\n # Or ignore small clusters and just aim for accuracy\n if len(node.labels) > 0:\n node.label = node.labels.most_common(1)[0][0]\n else:\n node.label = ''\n self.ready_for_prediction = True\n\n # Return the label of the best matching unit for the given test_vectors\n if isinstance(test_vectors, collections.Iterable):\n return [self.bmu(test_vector).label for test_vector in test_vectors]\n else:\n return self.bmu(test_vectors).label","def _predict(self, testX):\n pass","def predict(self, test_file_path: str) -> List[Dict[str, float]]:\n # TODO write code to extract features from test_file_path and \n # predict the labels for the model.\n pass","def knnTest(k, knnTrained, dataTest):\n x_test = []\n for data in dataTest:\n x_test.append(data[0])\n\n y_pred = knnTrained.predict(x_test)\n\n print(\" + Pred: {class: \", y_pred, ', character: ', mapOfCharacters[y_pred[0]], '}')\n \n return y_pred","def predict(self, testFeatures): \r\n\r\n if(not self._fitCalled):\r\n print('The fit method has not been called yet')\r\n return None\r\n\r\n l,d = testFeatures.shape\r\n n,d = self.data.shape \r\n\r\n \"\"\" Fill and return this in your implementation. \"\"\"\r\n predictions = np.empty(shape=(l,), dtype=self.labels.dtype)\r\n\r\n \"\"\" Implement kNN prediction here. \"\"\"\r\n\r\n for i in range(0, l):\r\n distances = []\r\n for j in range(0, n):\r\n distances.append((np.sqrt(np.sum((testFeatures[i]-self.data[j])**2)), self.labels[j]))\r\n distances.sort()\r\n kNearestLabels = [x[1] for x in distances][0:self.k]\r\n most_common, num_most_common = Counter(kNearestLabels).most_common(1)[0]\r\n predictions[i] = most_common\r\n return predictions","def predict(self, model, x_test):\n pass","def fit_predict(self, X, y=None, sample_weight=None):\r\n return self.fit(X, sample_weight=sample_weight).labels_","def predict(self, instances):\n\n if self.w is None or self.b is None:\n raise ValueError('Must train learner before prediction.')\n\n fvs, _ = TRIMLearner.get_fv_matrix_and_labels(instances)\n\n labels = fvs.dot(self.w) + self.b\n labels = list(map(lambda x: 1 if x >= 0 else -1, labels))\n\n return labels","def predict(self, test_data):\n return self.leader.predict(test_data)","def predict(self, X_test):\n if self.w is None: self.learn()\n \n Xt = np.append(np.ones((X_test.shape[0], 1)), X_test, axis=1)\n return np.dot(Xt, self.w)","def _predict(self, classify: np.array, n_preds=1):\r\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\r\n preds = copy(tmp) # allow to copy tmp\r\n for index, target in enumerate(self.targets):\r\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\r\n self.preds = preds","def predictSVM(w, x):\n \n # compute activation for test example and threshold the result\n a = np.dot(w, x);\n label = 1 if a > 0 else -1;\n \n return label;","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n # A list of length k storing the labels of the k nearest neighbors to\n # the ith test point.\n closest_y = []\n closest_y = self.y_train[np.argsort(dists[i])][0:k]\n closest_y = closest_y.astype(int)\n y_pred[i] = np.bincount(closest_y).argmax()\n return y_pred","def predict(self): \n return self.model.predict(self.test_x)","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n indices = np.argsort(dists[i])[:k]\n closest_y = self.y_train[indices]\n y_pred_i = mode(closest_y)[0]\n y_pred[i] = y_pred_i\n return y_pred","def predict(self, test_set_):\n\n test_set = np.array(test_set_)\n n_samples, n_features = test_set.shape\n\n assert n_features == self.features\n\n single_feature = test_set[:, self.bestn]\n h = np.ones((n_samples))\n h[single_feature*self.bestd < self.bestp*self.bestd] = -1\n return h","def getPredictions(self):\n\t\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)","def fit_predict(self, X, y=None, sample_weight=None):\n self.fit(X, sample_weight=sample_weight)\n return self.labels_","def predict(self, test):\n test_data = np.asarray(test)\n assert self.x is not None and self.y is not None, \"You must train the classifier before testing\"\n results = []\n for i in range(test_data.shape[0]):\n m = self.x - test_data[i]\n # dist holds the Euclidean distance to every training point\n dist = np.sum(m*m, 1)\n # this call uses a quickselect algo to find k-smallest\n ind = np.argpartition(dist, self.k)[:self.k]\n # take the class present the most among the k closest\n out = int(scipy.stats.mode(self.y[ind], axis=None)[0])\n results.append(out)\n return results","def predict(self, X):\r\n num_test = X.shape[0]\r\n # lets make sure that the output type matches the input type\r\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\r\n\r\n # loop over all test rows\r\n for i in range(num_test):\r\n print (\"Testing example \" + str(i))\r\n distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\r\n # distances = self.chi2_distance(self.Xtr, X[i,:])\r\n min_index = np.argmin(distances) # get the index with smallest distance\r\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\r\n print (\"Class Label: \" + str(Yte[i]) + \" \" + \"Predicted label: \" + str(Ypred[i]))\r\n return Ypred","def predict(self, x_test):\n x_test = self.add_x_0(x_test)\n y_predict = sigmoid(x_test @ self.weights) >= 0.5\n return y_predict.astype(int)","def predictAuthors(training_fvs, labels, test_fvs):\n clf = MultinomialNB()\n clf.fit(training_fvs, labels)\n return clf.predict(test_fvs)","def predict_labels(self, dists, k=1):\n num_test = dists.shape[0]\n y_pred = np.zeros(num_test)\n for i in range(num_test):\n # A list of length k storing the labels of the k nearest neighbors to\n # the ith test point.\n closest_y = []\n indices = np.argsort(dists[i])\n indices = indices[range(k)]\n closest_y = self.y_train[indices]\n counts = np.bincount(closest_y)\n y_pred[i] = np.argmax(counts)\n\n return y_pred","def test():\n # load dataset and model\n X, observed_y = load_data('../data/dev.txt')\n\n model = pickle.load(open('test.model', 'rb'))\n model.traverse()\n\n # predict labels for dataset\n preds = model.predict(X)\n\n # print(preds)\n # output model predictions\n np.savetxt('test.predictions', preds, fmt='%s')","def test(self) -> None:\n\n self._predictions = self._lr.predict(self._X_test)","def predict(self, testFeatures):\r\n\r\n if(not self._fitCalled):\r\n print('The fit method has not been called yet')\r\n return None \r\n\r\n preProcTestFeatures = self.pp.preProc(testFeatures)\r\n \"\"\" \r\n Implement the prediction method for the linear regression below.\r\n\r\n Hint: X*w = b\r\n where w is the learned weight vector, \r\n X is the matrix that should be built from the data and the bias terms \r\n and b is the prediction\r\n\r\n The preprocessing call has been handled for you\r\n \"\"\"\r\n w = self.w\r\n X= add_ones(preProcTestFeatures)\r\n b = X.dot(w)\r\n return b","def predict_label(self, x, weight=None, cutting=0.5, predict_label=None):\n if predict_label is None:\n predict_label = self.pred_label\n if weight is None: weight = self.weights[-1]\n pred = self.predict(x, weight, cutting)\n pred[np.where(pred == 0)] = predict_label[0]\n pred[np.where(pred == 1)] = predict_label[1]\n return pred","def predict_labels_logistic(self, weights, data):\n y_pred = sigmoid(np.dot(data, weights))\n y_pred[np.where(y_pred < 0.5)] = 0\n y_pred[np.where(y_pred >= 0.5)] = 1\n return y_pred","def predict(features, weights, bias):\n z = pre_activation(features, weights, bias)\n # Get normalized scores\n y = activation(z)\n # Get 0 or 1 value\n return np.round(y)","def predict(self,Xtest,nn_list):\n\n #calculate distances first\n self.dist_calc(Xtest)\n\n ypred = []\n\n for nn in nn_list:\n\n neigh_ind = self.ind[:,0:nn]\n\n if self.weights == 'uniform':\n\n p = np.mean(self.ytrain[neigh_ind], axis=1)\n\n elif self.weights =='distance':\n\n p = np.empty((self.dist.shape[0], self.ytrain.shape[1]), dtype=np.float)\n\n for i in range(self.ytrain.shape[1]):\n p[:,i] = utilities.weighted_mean(self.ytrain[neigh_ind,i], self.dist[:,0:nn])\n\n ypred.append(p)\n\n self.ypred = ypred\n self.nn_list = nn_list\n return ypred","def pp_labels(y_train, y_dev, y_test):\n\n lb = LabelBinarizer()\n ym_train = lb.fit_transform(y_train).T\n ym_dev = lb.fit_transform(y_dev).T\n ym_test = lb.fit_transform(y_test).T\n\n return ym_train, ym_dev, ym_test","def predict(self):\n train_array = np.array(self.labels != 0, dtype=float)\n if not self.ising:\n labels_logit = self.ising_weights['vertices']\n else:\n neigh_num = self.adj.dot(train_array)\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\n neigh_weights = self.ising_weights['edges'] * self.labels\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\n + self.ising_weights['vertices'])\n self.prediction = np.where(labels_logit > 0, 1, -1)\n return self","def test_test_model(self):\n\n dataset = ClassificationTestDataset()\n model = ClassificationTestModel(dataset)\n preds = list(model.predict(dataset.examples))\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\n self.assertEqual(np.argmax(preds[3]['preds']), 3)","def predict(self, X):\n num_test = X.shape[0]\n # lets make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\n\n # loop over all test rows\n for i in range(num_test):\n # find the nearest training image to the i'th test image\n # using the L1 distance (sum of absolute value differences)\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1) # L1 distance\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i, :]), axis=1)) # L2 distance\n min_index = np.argmin(distances) # get the index with smallest distance\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\n\n return Ypred","def train(image, labels, weights, learning_rate=0.01):\n label = np.argmax(labels)\n y_hat = predict(image, weights)\n active_img = image > np.mean(image)\n weights[label, active_img ] += learning_rate\n if y_hat != label:\n weights[y_hat, active_img ] -= learning_rate\n return y_hat, weights","def predict(self, test_data):\n random.seed(self.seed)\n preds = [{\"id\": instance['id'], \"prediction\": random.choice([0, 1])} for instance in test_data]\n return preds","def _predict_label(self, df_train, df_test, label=None):\n #train k-nearest neighbors classifier \n neigh = KNeighborsClassifier(n_neighbors=5)\n X, y = df_train[['longitude', 'latitude']], df_train[label]\n neigh.fit(X, y)\n #predict the label for wildfire incidents\n pred_label = neigh.predict(df_test[['longitude', 'latitude']])\n return pred_label","def predict(self, x, weight):\n pred = np.dot(x, weight)\n pred[np.where(pred <= 0)] = -1\n pred[np.where(pred > 0)] = 1\n return pred","def predict_labels(self, distances, k=1):\n\n num_test = distances.shape[0]\n Y_pred = np.zeros((num_test,))\n\n \n for i in range(num_test):\n # extracting k-nearest-neighbors for each test-point\n kNN_idxs = np.argsort(distances[i,:])[0:k]\n \n # voting among the k-nearest-neighbors\n kNN_labels = {}\n # print(type(kNN_labels))\n\n for j in range(k):\n m_label = self.Y_train[kNN_idxs[j]]\n if m_label in kNN_labels.keys():\n # print(type(kNN_labels))\n kNN_labels[m_label] += 1 # increment count\n else:\n # print(m_label,'....', type(kNN_labels))\n kNN_labels[m_label] = 1 # initial count when the label occurs\n \n # counting the winning label\n\n winning_label = kNN_labels.keys()[0] # initialization\n \n for label in kNN_labels.keys():\n if kNN_labels[label] > kNN_labels[winning_label]:\n winning_label = label\n elif kNN_labels[label] == kNN_labels[winning_label]:\n # tie breaker\n if label < winning_label:\n winning_label = label\n \n\n Y_pred[i] = winning_label # storing winning label for each test-point\n \n return Y_pred","def eval_performance(weights, test_y, test_x):\n y_predicted = predict_labels(weights, test_x)\n accuracy = len(y_predicted[y_predicted == test_y]) / len(y_predicted)\n return accuracy","def predict_ensemble(test_df):\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \n for review in list(test_df.review)]\n model_paths = glob('output_*/model.tar.gz')\n all_predicted_labels = []\n for model_path in model_paths:\n archive = load_archive(model_path) # load trained model\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \n for instance in instances]\n all_predicted_labels.append(predicted_labels)\n all_predicted_labels = np.array(all_predicted_labels)\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\n test_df['rating'] = predicted_labels_vote\n return test_df.drop('review', axis=1)","def predict(self, X_test):\n return self.model.predict(X_test)","def predict(self, inputs):\n if self.use_logistic:\n return self.predict_labels_logistic(self.w, inputs)\n return predict_labels(self.w, inputs)","def predict(self, X_test):\n \n X_test = np.insert(X_test, 0, 1, axis=1)\n Y_out = self.W.T.dot(X_test.T)\n pred = np.argmax(Y_out, axis=0)\n \n \n return pred","def predict(self, data):\n xdata, _ = self.array_from_cases(data)\n preds = self.model.predict(xdata)\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\n return label_preds","def predict(W, b, X, Y):\n m = Y.shape[1]\n \n \"\"\" Forward propagation on the images in the test set \"\"\"\n A = sigmoid(np.dot(W.T, X) + b)\n \n \"\"\" \n Use the activation values to make a prediction by the model.\n If the activation is > 0.5, that means our model predicts class 1\n else class 0. That's just the way we have set up. We can \n set it up any which way and train the model accordingly.\n \"\"\"\n Y_prediction = A > 0.5\n \n \"\"\" Finally finding out how many predictions we got right \"\"\"\n return np.sum(Y_prediction == Y) * 100 / m","def predict_label(self, src): # real signature unknown; restored from __doc__\n pass","def predict(self):\n self.predicted_test_summary = []\n for step in xrange(0, self.test_size // self.test_batch_size):\n print 'Predicting Batch No.:', step\n offset = (step * self.test_batch_size) % self.test_size\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\n self.predicted_test_summary.extend(summary_test_out)\n\n print 'Prediction Complete. Moving Forward..'\n\n # test answers\n self.test_review = self.X_tst_fwd\n self.predicted_test_summary = self.predicted_test_summary\n self.true_summary = self.Y_tst","def predict(wav, labels, graph, input_name, output_name, how_many_labels):\n pred_lab, pred_prob=label_wav(wav, labels, graph, input_name, output_name, how_many_labels)\n return pred_lab, pred_prob","def nnPredict(w1,w2,data): \r\n \r\n labels = np.array([])\r\n #Your code here\r\n #Get bias dimension\r\n bias_dimension = data.shape[0]\r\n\r\n #Fill it all with ones\r\n bias = np.ones((bias_dimension,1))\r\n\r\n #Add bias to weights \r\n data_with_bias = np.concatenate((data,bias),1)\r\n\r\n #Feed Foward Start By Multiplying Training data by weights of w1\r\n z2 = np.dot(data_with_bias,np.transpose(w1))\r\n\r\n #Apply Sigmoid function\r\n a2= sigmoid(z2)\r\n #Apply Another Bias Dimension to the new matrix\r\n\r\n #bias_dimension=a2.shape[0]\r\n #bias = np.ones((bias_dimension,1))\r\n a2_bias= np.concatenate((a2,bias),1)\r\n\r\n #Multiply new matrix by the weights of w2\r\n z3 = np.dot(a2_bias,np.transpose(w2))\r\n \r\n #Apply Sigmoid Function to the new data\r\n y= sigmoid(z3)\r\n\r\n #find max value and add that digit to the labels vector\r\n labels= np.zeros((y.shape[0],1))\r\n count=0\r\n for x in y:\r\n index=0\r\n max=0\r\n inmax=0\r\n for p in x:\r\n if p >= max:\r\n max=p\r\n inmax=index\r\n index+=1\r\n labels[count][0]=inmax\r\n count+=1\r\n \r\n print('results n ', labels)\r\n return labels","def predict(self, X_test):\n predicted_label = [self._predict(x_test) for x_test in X_test]\n\n return np.array(predicted_label)","def predict(self, Xtest):\n ytest = np.zeros(Xtest.shape[0], dtype=int)\n\n ### YOUR CODE HERE\n sig = np.dot(Xtest, self.weights)\n sig = utils.sigmoid(sig)\n #print (sig)\n sig = np.round(sig)\n #print (sig)\n for i in range (0, ytest.shape[0]):\n ytest[i] = int(sig[i])\n ### END YOUR CODE\n #print (ytest)\n assert len(ytest) == Xtest.shape[0]\n return ytest","def predict(self, test_data):\r\n return self.gs.predict(test_data)","def test_text_classifier_get_labels(self):\n pass","def predict(self, xs, **kwargs):","def kNN(k, testTfidf, trainTfidf, test_file, train_label, weight=True):\r\n test_y = [] \r\n \r\n # iterate through all lines in the test reviews and classify them\r\n for index, line in enumerate(test_file):\r\n # cosine similarity\r\n cos_similarity = linear_kernel(testTfidf[index:index+1], trainTfidf).flatten()\r\n \r\n if weight == True:\r\n # get the indices of nearest neighbors based on k parameter \r\n neighbor_indices = cos_similarity.argsort()[:-k:-1]\r\n # similarities\r\n similarities = cos_similarity[neighbor_indices]\r\n # get a list of labels from the neighbors and sum the list\r\n labels_list = train_label[neighbor_indices].tolist()\r\n\r\n # make cosine similarity value negative or positive based on\r\n # its label and sum the cosine similarities\r\n my_list = [] \r\n for s, l in zip(similarities, labels_list):\r\n if l == -1:\r\n my_list.append(-s)\r\n else:\r\n my_list.append(s) \r\n \r\n label_sum = sum(my_list)\r\n #classify based on label_sum\r\n if label_sum > 0:\r\n test_y.append(\"+1\")\r\n else:\r\n test_y.append(-1)\r\n\r\n else:\r\n # get the indices of nearest neighbors based on k parameter \r\n neighbor_indices = cos_similarity.argsort()[:-k:-1]\r\n # get a list of labels from the neighbors and sum the list\r\n labels_list = train_label[neighbor_indices].tolist()\r\n label_sum = sum(labels_list)\r\n\r\n # classify based on label_sum\r\n if label_sum > 0:\r\n test_y.append(\"+1\")\r\n else:\r\n test_y.append(-1)\r\n \r\n print(index)\r\n \r\n return pd.DataFrame(test_y)","def predict(self):\n\n if self.test_file is not None:\n for user in self.test_set['users']:\n pu = self.p[self.user_to_user_id[user]] + self.y_sum_rows(self.user_to_user_id[user])\n\n for item in self.test_set['feedback'][user]:\n self.predictions.append(\n (user, item, self._predict_svd_plus_plus_score(self.user_to_user_id[user],\n self.item_to_item_id[item], pu, True)))\n else:\n raise NotImplemented","def mapk(y_true, y_pred, k, sample_weight=None):\n def apk(actual, predict, weight, k):\n if len(predict)>k:\n predict = predict[:k]\n score = 0.0\n nums = 0.0\n for i,p in enumerate(predict):\n if p in actual and p not in predict[:i]:\n nums += 1.0\n score += nums / (i+1.0)\n return score / min(len(actual), k)*weight if actual else 0.0\n sample_weight = _sample_weight(y_true, sample_weight)\n return pd.DataFrame({'label1':y_true, 'label2':y_pred, 'weight':sample_weight}).apply(lambda x:apk(x[0], x[1], x[2], k=k), axis=1).mean()","def fit_predict(self):\n self.classifier = self.model\n self.classifier.fit(self.X_sample, self.y_sample)\n self.y_pred = self.classifier.predict(self.X_test)","def __call__(self, y, pred, sample_weight=None):","def predict_only(self):","def predict(self, X):\n\n num_test=X.shape[0]\n\n #make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\n\n #Loop over all test rows\n for i in xrange(num_test): #https://www.geeksforgeeks.org/range-vs-xrange-python/\n #find the nearest training image to the ith test image\n #using the L1 distance (sum of absolute value differences)\n print \"Running test example %d\" % (i)\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\n distances = np.sum(np.square(self.Xtr - X[i,:]), axis=1)\n min_index = np.argmin(distances) #get the index with the smallest distance\n Ypred[i] = self.ytr[min_index] #predict the lable of the nearest example\n\n return Ypred","def predict(self, X):\n num_test = X.shape[0] #records the number of rows\n # lets make sure that the output type matches the input type\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype) #with num_test rows of zeroes\n\n # loop over all test rows\n for i in range(num_test):\n # find the nearest training image to the i'th test image\n # using the L1 distance (sum of absolute value differences)\n \n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i,:]))) #another way of getting the distances, sqrt of sum of squares (standard)\n \n min_index = np.argmin(distances) # get the index with smallest distance\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\n\n return Ypred #will have a prediction index Ypred[i] for each row/test image at i","def predict_label(examples_set):\n all_labels = list(('yes', 'no'))\n prediction = 'no'\n\n for label in all_labels:\n all_same_label = True\n for example in examples_set:\n if example[14] != label:\n all_same_label = False\n break\n if all_same_label:\n prediction = label\n break\n return prediction","def predict_individual(self,Xtest,nn_list):\n\n #calculate distances first\n self.dist_calc(Xtest)\n\n ypred = []\n\n\n for nn in nn_list:\n\n neigh_ind = self.ind[:,nn-1] #subtract 1 since it is zero based\n\n ypred.append(self.ytrain[neigh_ind])\n\n self.ypred = ypred\n\n return ypred","def predict_individual(self,Xtest,nn_list):\n\n #calculate distances first\n self.dist_calc(Xtest)\n\n ypred = []\n\n\n for nn in nn_list:\n\n neigh_ind = self.ind[:,nn-1]# subtract 1 since it is zero based\n\n ypred.append(self.ytrain[neigh_ind])\n\n self.ypred = ypred\n\n return ypred","def predict(self, testX):\n predicted = self.model.predict(testX)\n return predicted","def test_predict(self):\n\n docs = self.docs\n for m in self.models:\n preds = m.predict(docs)\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertEqual(len(preds), len(docs))\n self.assertEqual(preds.dtype, int)\n\n preds = m.predict(docs, output_type=\"probability\")\n self.assertTrue(isinstance(preds, turicreate.SArray))\n self.assertTrue(len(preds) == len(docs))\n s = preds.apply(lambda x: sum(x))\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\n\n # Test predictions when docs have new words\n new_docs = turicreate.SArray([{\"-1,-1\": 3.0, \"0,4\": 5.0, \"0,3\": 2.0}])\n preds = m.predict(new_docs)\n self.assertEqual(len(preds), len(new_docs))\n\n # Test additional burnin. Ideally we could show that things\n # converge as you increase burnin.\n preds_no_burnin = m.predict(docs, output_type=\"probability\", num_burnin=0)\n self.assertEqual(len(preds_no_burnin), len(docs))","def predict(self, X, y=None):\n # Check is fit had been called\n check_is_fitted(self, ['X_', 'y_'])\n\n _, Predicted_Labels =\\\n RankSVM_test(test_data=X,\n num_class=self.num_class,\n Weights=self.Weights,\n Bias=self.Bias,\n SVs=self.SVs,\n svm=self.svm, gamma=self.gamma,\n coefficient=self.coefficient,\n degree=self.degree)\n\n return Predicted_Labels","def evaluate(y_test, pred_labels):\n \n # Converts one-hot code to a label (the index of 1)\n y_test_labels = np.argmax(y_test, axis=1)\n \n # Compare test labels to predicted labels\n score = accuracy_score(y_test_labels, pred_labels)\n \n return y_test_labels, score","def predict(model, X):\n\tmodel.eval()\n\t# make the predictions\n\tscores = model.forward(X)\n\n\t# scores contains, for each example, two scores that can be interpreted as the\n\t# probability of each example belonging to each of the classes. To select the\n\t# final predicted label, we will select the class with higher probability.\n\tpredicted_labels = scores.argmax(dim=-1) # predicted_labels shape: (n_examples)\n\n\treturn predicted_labels","def predict(self, unknown):\n for title in unknown:\n for ind in range(len((unknown[list(unknown.keys())[0]]))):\n unknown[title][ind] = (unknown[title][ind] - self.normalization_n[ind]) / (self.normalization_d[ind])\n print(unknown)\n unknown_labels = {}\n for title in unknown:\n neighbors = self.k_neighbors(unknown[title], self.dataset, self.k)\n unknown_labels[title] = self.rate(neighbors, self.labels)\n return unknown_labels","def predict(self,Xtest,nn_list):\n\n self.dist_calc(Xtest)\n xsize = self.dist.shape[0]\n ysize = self.ytrain.shape[1]\n ypred = []\n\n for nn in nn_list:\n\n yp = np.empty((xsize,ysize))\n\n if self.weights =='uniform':\n\n neigh_ind = self.ind[:,0:nn]\n\n for j in range(self.ytrain.shape[1]):\n\n mode = utilities.quick_mode_axis1_keep_nearest_neigh(\n self.ytrain[neigh_ind,j].astype(int))\n yp[:,j] = mode\n\n\n elif self.weights=='distance':\n dist = self.dist[:,0:nn]\n neigh_ind = self.ind[:,0:nn]\n W = 1./(dist+.000001) #to make sure we dont divide by zero\n\n for j in range(self.ytrain.shape[1]):\n mode, _ = utilities.weighted_mode(self.ytrain[neigh_ind,j].astype(int), W, axis=1)\n\n mode = np.asarray(mode.ravel(), dtype=int)\n\n yp[:, j] = mode\n\n ypred.append(yp)\n\n self.ypred = ypred\n\n return ypred","def predict(model, X_testing):\n predictions = model.predict(X_testing)\n\n return predictions","def predict_boosting_example(x, h_ens):\r\n\r\n arr = []\r\n sum_alpha = 0\r\n\r\n for y in h_ens:\r\n # splitting hypothesis, weight pairs\r\n alpha, tree = h_ens[y]\r\n tst_pred = predict_example(x, tree)\r\n # appending prediction\r\n arr.append(tst_pred*alpha)\r\n sum_alpha += alpha\r\n predict_egz = np.sum(arr) / sum_alpha\r\n # weak learner\r\n if predict_egz >= 0.5:\r\n return 1\r\n else:\r\n return 0","def mlp_test(a0, weights):\n a1 = tf.tanh(tf.matmul(a0, weights[0]))\n prediction = tf.reduce_sum(a1, axis = 1, keepdims = True)\n return prediction","def test_predict(self):\n \n\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"count\")\n \n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\"text\", method=\"tfidf\")\n \n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\n\n \n \"\"\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\"\"\" \n \n self.assertIsInstance(predict(model,x_testing),\n np.ndarray)\n \n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())","def testLogRegres(weights, dev_x, dev_y):\n predict_y = []\n numSamples, numFeatures = np.shape(dev_x)\n for i in range(numSamples):\n if sigmoid(dev_x[i, :] * weights) > 0.5:\n label = 1\n else:\n label = 0\n predict_y.append(label)\n print('Congratulations, testing complete!')\n return predict_y","def supervised_predict(model, X_test, labels, n_words=10, output_format=\"df\"):\n \n proba = model.predict_proba(X_test)\n proba_df = pd.DataFrame(0, \n index=X_test.index, \n columns=labels)\n for i, c in enumerate(proba_df.columns):\n proba_df.loc[:,c] = list(zip(*proba[i]))[1]\n\n Y_pred = pd.DataFrame(0, \n index=X_test.index, \n columns=labels)\n if output_format == \"df\":\n for idx in proba_df.index: # quite long time loops to optimize if possible\n col = proba_df.loc[idx, :].nlargest(n_words).index\n Y_pred.loc[idx, col] = 1\n return Y_pred\n \n elif output_format == \"list\":\n pred_l = []\n for idx in proba_df.index: # quite long time loops to optimize if possible\n col = proba_df.loc[idx, :].nlargest(n_words).index\n pred_l.append(Y_pred.loc[idx, col].columns)\n return pred_l","def test_model (self, text_test, labels_test):\n print(classification_report(labels_test, self.classify(text_test)))","def predict(self, x):\n pred_labels = np.zeros((x.shape[0], 10))\n\n N = len(self.NET)\n for i in range(N):\n\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\n pred_labels += self.NET[i].model.predict(inputs)\n\n return pred_labels","def predict(x_tst, model):\n\n predictions = model.predict(x_tst)\n return predictions","def knn(train_data, train_labels, test_data, test_labels, k):\n pred_labels = []\n for t in test_data:\n dist = calculate_distances(train_data, t)\n pred_class = majority_voting(dist, train_labels, k)\n pred_labels.append(pred_class)\n correct_pred_count = np.sum(pred_labels == test_labels)\n acc = correct_pred_count/len(test_labels)\n return acc"],"string":"[\n \"def predict(test_dataset,test_tX,weights):\\n for idx, dataset in enumerate(test_tX):\\n test_dataset[idx]['Prediction'] = predict_labels(weights[idx],dataset)\\n return test_dataset\",\n \"def predictTest(k, train, test):\\r\\n\\r\\n pred_labels = []\\r\\n\\r\\n # for each instance in the testing dataset, calculate all L2 distance from all training instances\\r\\n for te in range(len(test)):\\r\\n all_D = np.zeros((len(train), 1))\\r\\n\\r\\n # calculate the L2 distance of the testing instance from each training instance\\r\\n for tr in range(len(train)):\\r\\n D = 0\\r\\n for var in range(len(train.columns)-1):\\r\\n # if feature is real-valued, add (testing value - training value)^2\\r\\n if train[var].dtype == np.float64 or train[var].dtype == np.int64:\\r\\n D += (test[var][te] - train[var][tr])**2\\r\\n # if feature is nominal, add 1 if testing and training values are different\\r\\n else:\\r\\n if test[var][te] != train[var][tr]:\\r\\n D += 1\\r\\n all_D[tr] = D**(1/2)\\r\\n\\r\\n # sort all L2 distances, select K closest neighbors, and choose the most prevalent label\\r\\n all_D = np.column_stack((all_D, np.array(range(len(train)))))\\r\\n all_D = all_D[np.argsort(all_D[:, 0])]\\r\\n prob_labels = train[len(train.columns)-1][all_D[0:k, 1]].as_matrix()\\r\\n pred_labels.append(Counter(prob_labels).most_common(1)[0][0])\\r\\n\\r\\n return pred_labels\",\n \"def predict(self, testing_set):\\r\\n # Run prediction by multiply inputs with the weight and map it\\r\\n # Through the activation function\\r\\n final_prob = 0\\r\\n probability = self.activation(self.weighted_sum(testing_set))\\r\\n prediction = self.threshold(probability)\\r\\n if prediction == 1:\\r\\n final_prob = probability\\r\\n else:\\r\\n final_prob = 1 - probability\\r\\n return [prediction, final_prob]\",\n \"def predict_and_test(weight, test_data, test_label, regression= \\\"logistic\\\"):\\n pred_test, _ = get_output(weight, test_data, regression= regression)\\n acc = get_accuracy(pred_test, test_label, regression= regression)\\n return acc, pred_test\",\n \"def predict_labels(weights, data):\\n y_pred = np.dot(data, weights)\\n y_pred[np.where(y_pred <= 0)] = -1\\n y_pred[np.where(y_pred > 0)] = 1\\n \\n return y_pred\",\n \"def predict_labels(weights, data):\\n y_pred = np.dot(data, weights)\\n y_pred[np.where(y_pred <= 0)] = -1\\n y_pred[np.where(y_pred > 0)] = 1\\n \\n return y_pred\",\n \"def predict_labels(weights, data):\\n y_pred = np.dot(data, weights)\\n y_pred[np.where(y_pred <= 0)] = -1\\n y_pred[np.where(y_pred > 0)] = 1\\n \\n return y_pred\",\n \"def predict(self, Xtest):\\n ytest = np.dot(Xtest, self.weights)\\n return ytest\",\n \"def predict(self, testData=[]):\\n result = []\\n for classValue in self._classAttrs:\\n #print(f'Computing Label: {classValue}, {self._classLabelMap[classValue]}')\\n result.append(self._computeCondProb(testData, classValue))\\n return self._classLabelMap[result.index(max(result))]\",\n \"def predict(self, params, test):\\n vect_logit = np.vectorize(logit)\\n vect_comp = np.vectorize(complement)\\n n_test = np.shape(test)[0]\\n prior = self.model_prior\\n conditional = self.model_conditional\\n K = len(prior)\\n p = np.shape(conditional)[1]\\n test_p = np.shape(test)[1]\\n if p != test_p:\\n print \\\"Error: Number of training and testing features differ\\\"\\n return\\n preds = []\\n weight = vect_logit(conditional)\\n # Stores weight matrix\\n condition_comp = vect_comp(conditional)\\n intercept = np.log(\\n prior) + np.sum(np.apply_along_axis(np.log, 1, condition_comp), axis=1)\\n # Stores intercept vector\\n weight = weight.transpose()\\n classifier = test.dot(weight) + intercept\\n preds = np.argmax(classifier, axis=1) + 1\\n # Add 1 because the classes have a 1-based index\\n preds = preds.reshape(n_test, 1)\\n return preds\",\n \"def predict_labels(model, x_test):\\n \\n pred = model.predict(x_test)\\n #pred_labels = model.predict_classes(x_test) # depricated\\n pred_labels = np.argmax(model.predict(x_test), axis=-1)\\n \\n return pred, pred_labels\",\n \"def predict(self):\\n self.get_test_data()\\n predicted_labels = []\\n for row in self.test_data:\\n predicted_labels.append(DecisionTree.predict_row(self.classifier, row))\\n return predicted_labels\",\n \"def predict(self, example):\\n label = \\\"\\\"\\n pred = -99.0\\n for w in self.weights:\\n current = np.asarray(example.fvector)\\n i = self.weights[w] @ current\\n if i > pred:\\n pred = i\\n label = w\\n return label\",\n \"def predict(self):\\n add = np.ones(len(self.X_test))\\n X_add = np.c_[add, self.X_test]\\n pred = np.dot(X_add, self.w_result.T)\\n\\n pred[pred > 0] = 1\\n pred[pred < 0] = 0\\n return pred\",\n \"def test_predict(self):\\n\\n classifier = BertCCAMClassifier()\\n classifier.load_model(\\\"models\\\")\\n prediction = classifier.predict([\\\"bartosz\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}])\\n\\n # with multiple labels\\n prediction = classifier.predict([\\\"ala bert\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"A\\\", \\\"B\\\")}])\\n\\n # in a batch\\n prediction = classifier.predict([\\\"bartosz\\\", \\\"adam\\\"])\\n self.assertEqual(prediction, [{\\\"labels\\\": (\\\"B\\\",)}, {\\\"labels\\\": (\\\"A\\\",)}])\",\n \"def predict(self, test_set, test_labels):\\n\\n with tf.Session() as self.tf_session:\\n self.tf_saver.restore(self.tf_session, self.models_dir + self.model_name)\\n return self.accuracy.eval({self.input_data: test_set, self.input_labels: test_labels})\",\n \"def predict(self, X_test):\\n\\n # Predict Label 0\\n i = 0\\n X = X_test\\n\\n # Retrieve trained classifier for label 0\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n result = np.zeros((X_test.shape[0], self.label_dim))\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n # iterator = tqdm.trange(1, self.label_dim)\\n iterator = range(1, self.label_dim)\\n for i in iterator:\\n # Predict Label i\\n\\n # Retrieve trained classifier for label i\\n clf = self.trained[i]\\n\\n # Make prediction\\n y = clf.predict(X)\\n\\n result[:, i] = y\\n\\n # Concatenate result to X\\n # X = sp.hstack([X, sp.csr_matrix(y)], format=\\\"csr\\\")\\n\\n return result\",\n \"def test(self, test_instances, test_labels):\\n scores = self.classifier.predict(test_instances)\\n # TODO: print report\",\n \"def predict(self, test_vectors):\\n # Calculate the best matching label for each node\\n if not self.ready_for_prediction:\\n # totals = sum((node.labels for node in self.codebook), Counter())\\n for node in self.codebook:\\n # Remove unlabeled hits\\n try:\\n node.labels.pop(None)\\n except KeyError:\\n pass\\n # # Take into account small clusters. A frequency approach\\n # freq_counter = Counter({label: count / totals[label]\\n # for label, count in node.labels.items()})\\n # if len(freq_counter) > 0:\\n # node.label = freq_counter.most_common(1)[0][0]\\n # else:\\n # node.label = ''\\n # Or ignore small clusters and just aim for accuracy\\n if len(node.labels) > 0:\\n node.label = node.labels.most_common(1)[0][0]\\n else:\\n node.label = ''\\n self.ready_for_prediction = True\\n\\n # Return the label of the best matching unit for the given test_vectors\\n if isinstance(test_vectors, collections.Iterable):\\n return [self.bmu(test_vector).label for test_vector in test_vectors]\\n else:\\n return self.bmu(test_vectors).label\",\n \"def _predict(self, testX):\\n pass\",\n \"def predict(self, test_file_path: str) -> List[Dict[str, float]]:\\n # TODO write code to extract features from test_file_path and \\n # predict the labels for the model.\\n pass\",\n \"def knnTest(k, knnTrained, dataTest):\\n x_test = []\\n for data in dataTest:\\n x_test.append(data[0])\\n\\n y_pred = knnTrained.predict(x_test)\\n\\n print(\\\" + Pred: {class: \\\", y_pred, ', character: ', mapOfCharacters[y_pred[0]], '}')\\n \\n return y_pred\",\n \"def predict(self, testFeatures): \\r\\n\\r\\n if(not self._fitCalled):\\r\\n print('The fit method has not been called yet')\\r\\n return None\\r\\n\\r\\n l,d = testFeatures.shape\\r\\n n,d = self.data.shape \\r\\n\\r\\n \\\"\\\"\\\" Fill and return this in your implementation. \\\"\\\"\\\"\\r\\n predictions = np.empty(shape=(l,), dtype=self.labels.dtype)\\r\\n\\r\\n \\\"\\\"\\\" Implement kNN prediction here. \\\"\\\"\\\"\\r\\n\\r\\n for i in range(0, l):\\r\\n distances = []\\r\\n for j in range(0, n):\\r\\n distances.append((np.sqrt(np.sum((testFeatures[i]-self.data[j])**2)), self.labels[j]))\\r\\n distances.sort()\\r\\n kNearestLabels = [x[1] for x in distances][0:self.k]\\r\\n most_common, num_most_common = Counter(kNearestLabels).most_common(1)[0]\\r\\n predictions[i] = most_common\\r\\n return predictions\",\n \"def predict(self, model, x_test):\\n pass\",\n \"def fit_predict(self, X, y=None, sample_weight=None):\\r\\n return self.fit(X, sample_weight=sample_weight).labels_\",\n \"def predict(self, instances):\\n\\n if self.w is None or self.b is None:\\n raise ValueError('Must train learner before prediction.')\\n\\n fvs, _ = TRIMLearner.get_fv_matrix_and_labels(instances)\\n\\n labels = fvs.dot(self.w) + self.b\\n labels = list(map(lambda x: 1 if x >= 0 else -1, labels))\\n\\n return labels\",\n \"def predict(self, test_data):\\n return self.leader.predict(test_data)\",\n \"def predict(self, X_test):\\n if self.w is None: self.learn()\\n \\n Xt = np.append(np.ones((X_test.shape[0], 1)), X_test, axis=1)\\n return np.dot(Xt, self.w)\",\n \"def _predict(self, classify: np.array, n_preds=1):\\r\\n tmp = classify.argsort()[:, :n_preds] # Return the index of the best label classification\\r\\n preds = copy(tmp) # allow to copy tmp\\r\\n for index, target in enumerate(self.targets):\\r\\n preds = np.where(tmp == index, target, preds) # Return the target label corresponding to the index\\r\\n self.preds = preds\",\n \"def predictSVM(w, x):\\n \\n # compute activation for test example and threshold the result\\n a = np.dot(w, x);\\n label = 1 if a > 0 else -1;\\n \\n return label;\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n # A list of length k storing the labels of the k nearest neighbors to\\n # the ith test point.\\n closest_y = []\\n closest_y = self.y_train[np.argsort(dists[i])][0:k]\\n closest_y = closest_y.astype(int)\\n y_pred[i] = np.bincount(closest_y).argmax()\\n return y_pred\",\n \"def predict(self): \\n return self.model.predict(self.test_x)\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n indices = np.argsort(dists[i])[:k]\\n closest_y = self.y_train[indices]\\n y_pred_i = mode(closest_y)[0]\\n y_pred[i] = y_pred_i\\n return y_pred\",\n \"def predict(self, test_set_):\\n\\n test_set = np.array(test_set_)\\n n_samples, n_features = test_set.shape\\n\\n assert n_features == self.features\\n\\n single_feature = test_set[:, self.bestn]\\n h = np.ones((n_samples))\\n h[single_feature*self.bestd < self.bestp*self.bestd] = -1\\n return h\",\n \"def getPredictions(self):\\n\\t\\tself.bestLabel = self.testingProbs.apply(lambda x: x.argmax(),1)\",\n \"def fit_predict(self, X, y=None, sample_weight=None):\\n self.fit(X, sample_weight=sample_weight)\\n return self.labels_\",\n \"def predict(self, test):\\n test_data = np.asarray(test)\\n assert self.x is not None and self.y is not None, \\\"You must train the classifier before testing\\\"\\n results = []\\n for i in range(test_data.shape[0]):\\n m = self.x - test_data[i]\\n # dist holds the Euclidean distance to every training point\\n dist = np.sum(m*m, 1)\\n # this call uses a quickselect algo to find k-smallest\\n ind = np.argpartition(dist, self.k)[:self.k]\\n # take the class present the most among the k closest\\n out = int(scipy.stats.mode(self.y[ind], axis=None)[0])\\n results.append(out)\\n return results\",\n \"def predict(self, X):\\r\\n num_test = X.shape[0]\\r\\n # lets make sure that the output type matches the input type\\r\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\\r\\n\\r\\n # loop over all test rows\\r\\n for i in range(num_test):\\r\\n print (\\\"Testing example \\\" + str(i))\\r\\n distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\r\\n # distances = self.chi2_distance(self.Xtr, X[i,:])\\r\\n min_index = np.argmin(distances) # get the index with smallest distance\\r\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\r\\n print (\\\"Class Label: \\\" + str(Yte[i]) + \\\" \\\" + \\\"Predicted label: \\\" + str(Ypred[i]))\\r\\n return Ypred\",\n \"def predict(self, x_test):\\n x_test = self.add_x_0(x_test)\\n y_predict = sigmoid(x_test @ self.weights) >= 0.5\\n return y_predict.astype(int)\",\n \"def predictAuthors(training_fvs, labels, test_fvs):\\n clf = MultinomialNB()\\n clf.fit(training_fvs, labels)\\n return clf.predict(test_fvs)\",\n \"def predict_labels(self, dists, k=1):\\n num_test = dists.shape[0]\\n y_pred = np.zeros(num_test)\\n for i in range(num_test):\\n # A list of length k storing the labels of the k nearest neighbors to\\n # the ith test point.\\n closest_y = []\\n indices = np.argsort(dists[i])\\n indices = indices[range(k)]\\n closest_y = self.y_train[indices]\\n counts = np.bincount(closest_y)\\n y_pred[i] = np.argmax(counts)\\n\\n return y_pred\",\n \"def test():\\n # load dataset and model\\n X, observed_y = load_data('../data/dev.txt')\\n\\n model = pickle.load(open('test.model', 'rb'))\\n model.traverse()\\n\\n # predict labels for dataset\\n preds = model.predict(X)\\n\\n # print(preds)\\n # output model predictions\\n np.savetxt('test.predictions', preds, fmt='%s')\",\n \"def test(self) -> None:\\n\\n self._predictions = self._lr.predict(self._X_test)\",\n \"def predict(self, testFeatures):\\r\\n\\r\\n if(not self._fitCalled):\\r\\n print('The fit method has not been called yet')\\r\\n return None \\r\\n\\r\\n preProcTestFeatures = self.pp.preProc(testFeatures)\\r\\n \\\"\\\"\\\" \\r\\n Implement the prediction method for the linear regression below.\\r\\n\\r\\n Hint: X*w = b\\r\\n where w is the learned weight vector, \\r\\n X is the matrix that should be built from the data and the bias terms \\r\\n and b is the prediction\\r\\n\\r\\n The preprocessing call has been handled for you\\r\\n \\\"\\\"\\\"\\r\\n w = self.w\\r\\n X= add_ones(preProcTestFeatures)\\r\\n b = X.dot(w)\\r\\n return b\",\n \"def predict_label(self, x, weight=None, cutting=0.5, predict_label=None):\\n if predict_label is None:\\n predict_label = self.pred_label\\n if weight is None: weight = self.weights[-1]\\n pred = self.predict(x, weight, cutting)\\n pred[np.where(pred == 0)] = predict_label[0]\\n pred[np.where(pred == 1)] = predict_label[1]\\n return pred\",\n \"def predict_labels_logistic(self, weights, data):\\n y_pred = sigmoid(np.dot(data, weights))\\n y_pred[np.where(y_pred < 0.5)] = 0\\n y_pred[np.where(y_pred >= 0.5)] = 1\\n return y_pred\",\n \"def predict(features, weights, bias):\\n z = pre_activation(features, weights, bias)\\n # Get normalized scores\\n y = activation(z)\\n # Get 0 or 1 value\\n return np.round(y)\",\n \"def predict(self,Xtest,nn_list):\\n\\n #calculate distances first\\n self.dist_calc(Xtest)\\n\\n ypred = []\\n\\n for nn in nn_list:\\n\\n neigh_ind = self.ind[:,0:nn]\\n\\n if self.weights == 'uniform':\\n\\n p = np.mean(self.ytrain[neigh_ind], axis=1)\\n\\n elif self.weights =='distance':\\n\\n p = np.empty((self.dist.shape[0], self.ytrain.shape[1]), dtype=np.float)\\n\\n for i in range(self.ytrain.shape[1]):\\n p[:,i] = utilities.weighted_mean(self.ytrain[neigh_ind,i], self.dist[:,0:nn])\\n\\n ypred.append(p)\\n\\n self.ypred = ypred\\n self.nn_list = nn_list\\n return ypred\",\n \"def pp_labels(y_train, y_dev, y_test):\\n\\n lb = LabelBinarizer()\\n ym_train = lb.fit_transform(y_train).T\\n ym_dev = lb.fit_transform(y_dev).T\\n ym_test = lb.fit_transform(y_test).T\\n\\n return ym_train, ym_dev, ym_test\",\n \"def predict(self):\\n train_array = np.array(self.labels != 0, dtype=float)\\n if not self.ising:\\n labels_logit = self.ising_weights['vertices']\\n else:\\n neigh_num = self.adj.dot(train_array)\\n neigh_num = np.where(neigh_num == 0, 1, neigh_num)\\n neigh_weights = self.ising_weights['edges'] * self.labels\\n labels_logit = (np.multiply(neigh_weights, neigh_num**(-1))\\n + self.ising_weights['vertices'])\\n self.prediction = np.where(labels_logit > 0, 1, -1)\\n return self\",\n \"def test_test_model(self):\\n\\n dataset = ClassificationTestDataset()\\n model = ClassificationTestModel(dataset)\\n preds = list(model.predict(dataset.examples))\\n self.assertEqual(np.argmax(preds[0]['preds']), 2)\\n self.assertEqual(np.argmax(preds[1]['preds']), 1)\\n self.assertEqual(np.argmax(preds[2]['preds']), 4)\\n self.assertEqual(np.argmax(preds[3]['preds']), 3)\",\n \"def predict(self, X):\\n num_test = X.shape[0]\\n # lets make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype)\\n\\n # loop over all test rows\\n for i in range(num_test):\\n # find the nearest training image to the i'th test image\\n # using the L1 distance (sum of absolute value differences)\\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1) # L1 distance\\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i, :]), axis=1)) # L2 distance\\n min_index = np.argmin(distances) # get the index with smallest distance\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\n\\n return Ypred\",\n \"def train(image, labels, weights, learning_rate=0.01):\\n label = np.argmax(labels)\\n y_hat = predict(image, weights)\\n active_img = image > np.mean(image)\\n weights[label, active_img ] += learning_rate\\n if y_hat != label:\\n weights[y_hat, active_img ] -= learning_rate\\n return y_hat, weights\",\n \"def predict(self, test_data):\\n random.seed(self.seed)\\n preds = [{\\\"id\\\": instance['id'], \\\"prediction\\\": random.choice([0, 1])} for instance in test_data]\\n return preds\",\n \"def _predict_label(self, df_train, df_test, label=None):\\n #train k-nearest neighbors classifier \\n neigh = KNeighborsClassifier(n_neighbors=5)\\n X, y = df_train[['longitude', 'latitude']], df_train[label]\\n neigh.fit(X, y)\\n #predict the label for wildfire incidents\\n pred_label = neigh.predict(df_test[['longitude', 'latitude']])\\n return pred_label\",\n \"def predict(self, x, weight):\\n pred = np.dot(x, weight)\\n pred[np.where(pred <= 0)] = -1\\n pred[np.where(pred > 0)] = 1\\n return pred\",\n \"def predict_labels(self, distances, k=1):\\n\\n num_test = distances.shape[0]\\n Y_pred = np.zeros((num_test,))\\n\\n \\n for i in range(num_test):\\n # extracting k-nearest-neighbors for each test-point\\n kNN_idxs = np.argsort(distances[i,:])[0:k]\\n \\n # voting among the k-nearest-neighbors\\n kNN_labels = {}\\n # print(type(kNN_labels))\\n\\n for j in range(k):\\n m_label = self.Y_train[kNN_idxs[j]]\\n if m_label in kNN_labels.keys():\\n # print(type(kNN_labels))\\n kNN_labels[m_label] += 1 # increment count\\n else:\\n # print(m_label,'....', type(kNN_labels))\\n kNN_labels[m_label] = 1 # initial count when the label occurs\\n \\n # counting the winning label\\n\\n winning_label = kNN_labels.keys()[0] # initialization\\n \\n for label in kNN_labels.keys():\\n if kNN_labels[label] > kNN_labels[winning_label]:\\n winning_label = label\\n elif kNN_labels[label] == kNN_labels[winning_label]:\\n # tie breaker\\n if label < winning_label:\\n winning_label = label\\n \\n\\n Y_pred[i] = winning_label # storing winning label for each test-point\\n \\n return Y_pred\",\n \"def eval_performance(weights, test_y, test_x):\\n y_predicted = predict_labels(weights, test_x)\\n accuracy = len(y_predicted[y_predicted == test_y]) / len(y_predicted)\\n return accuracy\",\n \"def predict_ensemble(test_df):\\n instances = [wongnai_predictor._dataset_reader.text_to_instance(word_tokenize(review)) \\n for review in list(test_df.review)]\\n model_paths = glob('output_*/model.tar.gz')\\n all_predicted_labels = []\\n for model_path in model_paths:\\n archive = load_archive(model_path) # load trained model\\n wongnai_predictor = Predictor.from_archive(archive, 'wongnai_predictor')\\n predicted_labels = [int(wongnai_predictor.predict_instance(instance)['predicted_label']) \\n for instance in instances]\\n all_predicted_labels.append(predicted_labels)\\n all_predicted_labels = np.array(all_predicted_labels)\\n predicted_labels_vote = mode(np.array(all_predicted_labels).T, axis=-1).mode.ravel()\\n test_df['rating'] = predicted_labels_vote\\n return test_df.drop('review', axis=1)\",\n \"def predict(self, X_test):\\n return self.model.predict(X_test)\",\n \"def predict(self, inputs):\\n if self.use_logistic:\\n return self.predict_labels_logistic(self.w, inputs)\\n return predict_labels(self.w, inputs)\",\n \"def predict(self, X_test):\\n \\n X_test = np.insert(X_test, 0, 1, axis=1)\\n Y_out = self.W.T.dot(X_test.T)\\n pred = np.argmax(Y_out, axis=0)\\n \\n \\n return pred\",\n \"def predict(self, data):\\n xdata, _ = self.array_from_cases(data)\\n preds = self.model.predict(xdata)\\n label_preds = [dict(zip(self.binarizer.classes_, pred)) for pred in preds]\\n return label_preds\",\n \"def predict(W, b, X, Y):\\n m = Y.shape[1]\\n \\n \\\"\\\"\\\" Forward propagation on the images in the test set \\\"\\\"\\\"\\n A = sigmoid(np.dot(W.T, X) + b)\\n \\n \\\"\\\"\\\" \\n Use the activation values to make a prediction by the model.\\n If the activation is > 0.5, that means our model predicts class 1\\n else class 0. That's just the way we have set up. We can \\n set it up any which way and train the model accordingly.\\n \\\"\\\"\\\"\\n Y_prediction = A > 0.5\\n \\n \\\"\\\"\\\" Finally finding out how many predictions we got right \\\"\\\"\\\"\\n return np.sum(Y_prediction == Y) * 100 / m\",\n \"def predict_label(self, src): # real signature unknown; restored from __doc__\\n pass\",\n \"def predict(self):\\n self.predicted_test_summary = []\\n for step in xrange(0, self.test_size // self.test_batch_size):\\n print 'Predicting Batch No.:', step\\n offset = (step * self.test_batch_size) % self.test_size\\n batch_data_fwd = self.X_tst_fwd[offset:(offset + self.test_batch_size), :].T\\n batch_data_bwd = self.X_tst_bwd[offset:(offset + self.test_batch_size), :].T\\n summary_test_out = self._predict_batch(batch_data_fwd, batch_data_bwd)\\n self.predicted_test_summary.extend(summary_test_out)\\n\\n print 'Prediction Complete. Moving Forward..'\\n\\n # test answers\\n self.test_review = self.X_tst_fwd\\n self.predicted_test_summary = self.predicted_test_summary\\n self.true_summary = self.Y_tst\",\n \"def predict(wav, labels, graph, input_name, output_name, how_many_labels):\\n pred_lab, pred_prob=label_wav(wav, labels, graph, input_name, output_name, how_many_labels)\\n return pred_lab, pred_prob\",\n \"def nnPredict(w1,w2,data): \\r\\n \\r\\n labels = np.array([])\\r\\n #Your code here\\r\\n #Get bias dimension\\r\\n bias_dimension = data.shape[0]\\r\\n\\r\\n #Fill it all with ones\\r\\n bias = np.ones((bias_dimension,1))\\r\\n\\r\\n #Add bias to weights \\r\\n data_with_bias = np.concatenate((data,bias),1)\\r\\n\\r\\n #Feed Foward Start By Multiplying Training data by weights of w1\\r\\n z2 = np.dot(data_with_bias,np.transpose(w1))\\r\\n\\r\\n #Apply Sigmoid function\\r\\n a2= sigmoid(z2)\\r\\n #Apply Another Bias Dimension to the new matrix\\r\\n\\r\\n #bias_dimension=a2.shape[0]\\r\\n #bias = np.ones((bias_dimension,1))\\r\\n a2_bias= np.concatenate((a2,bias),1)\\r\\n\\r\\n #Multiply new matrix by the weights of w2\\r\\n z3 = np.dot(a2_bias,np.transpose(w2))\\r\\n \\r\\n #Apply Sigmoid Function to the new data\\r\\n y= sigmoid(z3)\\r\\n\\r\\n #find max value and add that digit to the labels vector\\r\\n labels= np.zeros((y.shape[0],1))\\r\\n count=0\\r\\n for x in y:\\r\\n index=0\\r\\n max=0\\r\\n inmax=0\\r\\n for p in x:\\r\\n if p >= max:\\r\\n max=p\\r\\n inmax=index\\r\\n index+=1\\r\\n labels[count][0]=inmax\\r\\n count+=1\\r\\n \\r\\n print('results n ', labels)\\r\\n return labels\",\n \"def predict(self, X_test):\\n predicted_label = [self._predict(x_test) for x_test in X_test]\\n\\n return np.array(predicted_label)\",\n \"def predict(self, Xtest):\\n ytest = np.zeros(Xtest.shape[0], dtype=int)\\n\\n ### YOUR CODE HERE\\n sig = np.dot(Xtest, self.weights)\\n sig = utils.sigmoid(sig)\\n #print (sig)\\n sig = np.round(sig)\\n #print (sig)\\n for i in range (0, ytest.shape[0]):\\n ytest[i] = int(sig[i])\\n ### END YOUR CODE\\n #print (ytest)\\n assert len(ytest) == Xtest.shape[0]\\n return ytest\",\n \"def predict(self, test_data):\\r\\n return self.gs.predict(test_data)\",\n \"def test_text_classifier_get_labels(self):\\n pass\",\n \"def predict(self, xs, **kwargs):\",\n \"def kNN(k, testTfidf, trainTfidf, test_file, train_label, weight=True):\\r\\n test_y = [] \\r\\n \\r\\n # iterate through all lines in the test reviews and classify them\\r\\n for index, line in enumerate(test_file):\\r\\n # cosine similarity\\r\\n cos_similarity = linear_kernel(testTfidf[index:index+1], trainTfidf).flatten()\\r\\n \\r\\n if weight == True:\\r\\n # get the indices of nearest neighbors based on k parameter \\r\\n neighbor_indices = cos_similarity.argsort()[:-k:-1]\\r\\n # similarities\\r\\n similarities = cos_similarity[neighbor_indices]\\r\\n # get a list of labels from the neighbors and sum the list\\r\\n labels_list = train_label[neighbor_indices].tolist()\\r\\n\\r\\n # make cosine similarity value negative or positive based on\\r\\n # its label and sum the cosine similarities\\r\\n my_list = [] \\r\\n for s, l in zip(similarities, labels_list):\\r\\n if l == -1:\\r\\n my_list.append(-s)\\r\\n else:\\r\\n my_list.append(s) \\r\\n \\r\\n label_sum = sum(my_list)\\r\\n #classify based on label_sum\\r\\n if label_sum > 0:\\r\\n test_y.append(\\\"+1\\\")\\r\\n else:\\r\\n test_y.append(-1)\\r\\n\\r\\n else:\\r\\n # get the indices of nearest neighbors based on k parameter \\r\\n neighbor_indices = cos_similarity.argsort()[:-k:-1]\\r\\n # get a list of labels from the neighbors and sum the list\\r\\n labels_list = train_label[neighbor_indices].tolist()\\r\\n label_sum = sum(labels_list)\\r\\n\\r\\n # classify based on label_sum\\r\\n if label_sum > 0:\\r\\n test_y.append(\\\"+1\\\")\\r\\n else:\\r\\n test_y.append(-1)\\r\\n \\r\\n print(index)\\r\\n \\r\\n return pd.DataFrame(test_y)\",\n \"def predict(self):\\n\\n if self.test_file is not None:\\n for user in self.test_set['users']:\\n pu = self.p[self.user_to_user_id[user]] + self.y_sum_rows(self.user_to_user_id[user])\\n\\n for item in self.test_set['feedback'][user]:\\n self.predictions.append(\\n (user, item, self._predict_svd_plus_plus_score(self.user_to_user_id[user],\\n self.item_to_item_id[item], pu, True)))\\n else:\\n raise NotImplemented\",\n \"def mapk(y_true, y_pred, k, sample_weight=None):\\n def apk(actual, predict, weight, k):\\n if len(predict)>k:\\n predict = predict[:k]\\n score = 0.0\\n nums = 0.0\\n for i,p in enumerate(predict):\\n if p in actual and p not in predict[:i]:\\n nums += 1.0\\n score += nums / (i+1.0)\\n return score / min(len(actual), k)*weight if actual else 0.0\\n sample_weight = _sample_weight(y_true, sample_weight)\\n return pd.DataFrame({'label1':y_true, 'label2':y_pred, 'weight':sample_weight}).apply(lambda x:apk(x[0], x[1], x[2], k=k), axis=1).mean()\",\n \"def fit_predict(self):\\n self.classifier = self.model\\n self.classifier.fit(self.X_sample, self.y_sample)\\n self.y_pred = self.classifier.predict(self.X_test)\",\n \"def __call__(self, y, pred, sample_weight=None):\",\n \"def predict_only(self):\",\n \"def predict(self, X):\\n\\n num_test=X.shape[0]\\n\\n #make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype=self.ytr.dtype)\\n\\n #Loop over all test rows\\n for i in xrange(num_test): #https://www.geeksforgeeks.org/range-vs-xrange-python/\\n #find the nearest training image to the ith test image\\n #using the L1 distance (sum of absolute value differences)\\n print \\\"Running test example %d\\\" % (i)\\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\n distances = np.sum(np.square(self.Xtr - X[i,:]), axis=1)\\n min_index = np.argmin(distances) #get the index with the smallest distance\\n Ypred[i] = self.ytr[min_index] #predict the lable of the nearest example\\n\\n return Ypred\",\n \"def predict(self, X):\\n num_test = X.shape[0] #records the number of rows\\n # lets make sure that the output type matches the input type\\n Ypred = np.zeros(num_test, dtype = self.ytr.dtype) #with num_test rows of zeroes\\n\\n # loop over all test rows\\n for i in range(num_test):\\n # find the nearest training image to the i'th test image\\n # using the L1 distance (sum of absolute value differences)\\n \\n #distances = np.sum(np.abs(self.Xtr - X[i,:]), axis = 1)\\n distances = np.sqrt(np.sum(np.square(self.Xtr - X[i,:]))) #another way of getting the distances, sqrt of sum of squares (standard)\\n \\n min_index = np.argmin(distances) # get the index with smallest distance\\n Ypred[i] = self.ytr[min_index] # predict the label of the nearest example\\n\\n return Ypred #will have a prediction index Ypred[i] for each row/test image at i\",\n \"def predict_label(examples_set):\\n all_labels = list(('yes', 'no'))\\n prediction = 'no'\\n\\n for label in all_labels:\\n all_same_label = True\\n for example in examples_set:\\n if example[14] != label:\\n all_same_label = False\\n break\\n if all_same_label:\\n prediction = label\\n break\\n return prediction\",\n \"def predict_individual(self,Xtest,nn_list):\\n\\n #calculate distances first\\n self.dist_calc(Xtest)\\n\\n ypred = []\\n\\n\\n for nn in nn_list:\\n\\n neigh_ind = self.ind[:,nn-1] #subtract 1 since it is zero based\\n\\n ypred.append(self.ytrain[neigh_ind])\\n\\n self.ypred = ypred\\n\\n return ypred\",\n \"def predict_individual(self,Xtest,nn_list):\\n\\n #calculate distances first\\n self.dist_calc(Xtest)\\n\\n ypred = []\\n\\n\\n for nn in nn_list:\\n\\n neigh_ind = self.ind[:,nn-1]# subtract 1 since it is zero based\\n\\n ypred.append(self.ytrain[neigh_ind])\\n\\n self.ypred = ypred\\n\\n return ypred\",\n \"def predict(self, testX):\\n predicted = self.model.predict(testX)\\n return predicted\",\n \"def test_predict(self):\\n\\n docs = self.docs\\n for m in self.models:\\n preds = m.predict(docs)\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertEqual(len(preds), len(docs))\\n self.assertEqual(preds.dtype, int)\\n\\n preds = m.predict(docs, output_type=\\\"probability\\\")\\n self.assertTrue(isinstance(preds, turicreate.SArray))\\n self.assertTrue(len(preds) == len(docs))\\n s = preds.apply(lambda x: sum(x))\\n self.assertTrue((s.apply(lambda x: abs(x - 1)) < 0.000001).all())\\n\\n # Test predictions when docs have new words\\n new_docs = turicreate.SArray([{\\\"-1,-1\\\": 3.0, \\\"0,4\\\": 5.0, \\\"0,3\\\": 2.0}])\\n preds = m.predict(new_docs)\\n self.assertEqual(len(preds), len(new_docs))\\n\\n # Test additional burnin. Ideally we could show that things\\n # converge as you increase burnin.\\n preds_no_burnin = m.predict(docs, output_type=\\\"probability\\\", num_burnin=0)\\n self.assertEqual(len(preds_no_burnin), len(docs))\",\n \"def predict(self, X, y=None):\\n # Check is fit had been called\\n check_is_fitted(self, ['X_', 'y_'])\\n\\n _, Predicted_Labels =\\\\\\n RankSVM_test(test_data=X,\\n num_class=self.num_class,\\n Weights=self.Weights,\\n Bias=self.Bias,\\n SVs=self.SVs,\\n svm=self.svm, gamma=self.gamma,\\n coefficient=self.coefficient,\\n degree=self.degree)\\n\\n return Predicted_Labels\",\n \"def evaluate(y_test, pred_labels):\\n \\n # Converts one-hot code to a label (the index of 1)\\n y_test_labels = np.argmax(y_test, axis=1)\\n \\n # Compare test labels to predicted labels\\n score = accuracy_score(y_test_labels, pred_labels)\\n \\n return y_test_labels, score\",\n \"def predict(model, X):\\n\\tmodel.eval()\\n\\t# make the predictions\\n\\tscores = model.forward(X)\\n\\n\\t# scores contains, for each example, two scores that can be interpreted as the\\n\\t# probability of each example belonging to each of the classes. To select the\\n\\t# final predicted label, we will select the class with higher probability.\\n\\tpredicted_labels = scores.argmax(dim=-1) # predicted_labels shape: (n_examples)\\n\\n\\treturn predicted_labels\",\n \"def predict(self, unknown):\\n for title in unknown:\\n for ind in range(len((unknown[list(unknown.keys())[0]]))):\\n unknown[title][ind] = (unknown[title][ind] - self.normalization_n[ind]) / (self.normalization_d[ind])\\n print(unknown)\\n unknown_labels = {}\\n for title in unknown:\\n neighbors = self.k_neighbors(unknown[title], self.dataset, self.k)\\n unknown_labels[title] = self.rate(neighbors, self.labels)\\n return unknown_labels\",\n \"def predict(self,Xtest,nn_list):\\n\\n self.dist_calc(Xtest)\\n xsize = self.dist.shape[0]\\n ysize = self.ytrain.shape[1]\\n ypred = []\\n\\n for nn in nn_list:\\n\\n yp = np.empty((xsize,ysize))\\n\\n if self.weights =='uniform':\\n\\n neigh_ind = self.ind[:,0:nn]\\n\\n for j in range(self.ytrain.shape[1]):\\n\\n mode = utilities.quick_mode_axis1_keep_nearest_neigh(\\n self.ytrain[neigh_ind,j].astype(int))\\n yp[:,j] = mode\\n\\n\\n elif self.weights=='distance':\\n dist = self.dist[:,0:nn]\\n neigh_ind = self.ind[:,0:nn]\\n W = 1./(dist+.000001) #to make sure we dont divide by zero\\n\\n for j in range(self.ytrain.shape[1]):\\n mode, _ = utilities.weighted_mode(self.ytrain[neigh_ind,j].astype(int), W, axis=1)\\n\\n mode = np.asarray(mode.ravel(), dtype=int)\\n\\n yp[:, j] = mode\\n\\n ypred.append(yp)\\n\\n self.ypred = ypred\\n\\n return ypred\",\n \"def predict(model, X_testing):\\n predictions = model.predict(X_testing)\\n\\n return predictions\",\n \"def predict_boosting_example(x, h_ens):\\r\\n\\r\\n arr = []\\r\\n sum_alpha = 0\\r\\n\\r\\n for y in h_ens:\\r\\n # splitting hypothesis, weight pairs\\r\\n alpha, tree = h_ens[y]\\r\\n tst_pred = predict_example(x, tree)\\r\\n # appending prediction\\r\\n arr.append(tst_pred*alpha)\\r\\n sum_alpha += alpha\\r\\n predict_egz = np.sum(arr) / sum_alpha\\r\\n # weak learner\\r\\n if predict_egz >= 0.5:\\r\\n return 1\\r\\n else:\\r\\n return 0\",\n \"def mlp_test(a0, weights):\\n a1 = tf.tanh(tf.matmul(a0, weights[0]))\\n prediction = tf.reduce_sum(a1, axis = 1, keepdims = True)\\n return prediction\",\n \"def test_predict(self):\\n \\n\\n model ,vec, x_testing=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"count\\\")\\n \\n model2 ,vec_tfidf, x_testing2=setup_log_reg_classifier(self.training_data, self.training_y, self.testing_data,\\\"text\\\", method=\\\"tfidf\\\")\\n \\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with countVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\\n\\n \\n \\\"\\\"\\\" Test correct data types and corrrect range of predicted values (1,0) for predict with tfidfVectorizer\\\"\\\"\\\" \\n \\n self.assertIsInstance(predict(model,x_testing),\\n np.ndarray)\\n \\n self.assertTrue(([0,1] ==np.unique(predict(model2,x_testing2))).all())\",\n \"def testLogRegres(weights, dev_x, dev_y):\\n predict_y = []\\n numSamples, numFeatures = np.shape(dev_x)\\n for i in range(numSamples):\\n if sigmoid(dev_x[i, :] * weights) > 0.5:\\n label = 1\\n else:\\n label = 0\\n predict_y.append(label)\\n print('Congratulations, testing complete!')\\n return predict_y\",\n \"def supervised_predict(model, X_test, labels, n_words=10, output_format=\\\"df\\\"):\\n \\n proba = model.predict_proba(X_test)\\n proba_df = pd.DataFrame(0, \\n index=X_test.index, \\n columns=labels)\\n for i, c in enumerate(proba_df.columns):\\n proba_df.loc[:,c] = list(zip(*proba[i]))[1]\\n\\n Y_pred = pd.DataFrame(0, \\n index=X_test.index, \\n columns=labels)\\n if output_format == \\\"df\\\":\\n for idx in proba_df.index: # quite long time loops to optimize if possible\\n col = proba_df.loc[idx, :].nlargest(n_words).index\\n Y_pred.loc[idx, col] = 1\\n return Y_pred\\n \\n elif output_format == \\\"list\\\":\\n pred_l = []\\n for idx in proba_df.index: # quite long time loops to optimize if possible\\n col = proba_df.loc[idx, :].nlargest(n_words).index\\n pred_l.append(Y_pred.loc[idx, col].columns)\\n return pred_l\",\n \"def test_model (self, text_test, labels_test):\\n print(classification_report(labels_test, self.classify(text_test)))\",\n \"def predict(self, x):\\n pred_labels = np.zeros((x.shape[0], 10))\\n\\n N = len(self.NET)\\n for i in range(N):\\n\\n inputs = self.apply_dct_permutation(x.copy(), self.permutation[i])\\n pred_labels += self.NET[i].model.predict(inputs)\\n\\n return pred_labels\",\n \"def predict(x_tst, model):\\n\\n predictions = model.predict(x_tst)\\n return predictions\",\n \"def knn(train_data, train_labels, test_data, test_labels, k):\\n pred_labels = []\\n for t in test_data:\\n dist = calculate_distances(train_data, t)\\n pred_class = majority_voting(dist, train_labels, k)\\n pred_labels.append(pred_class)\\n correct_pred_count = np.sum(pred_labels == test_labels)\\n acc = correct_pred_count/len(test_labels)\\n return acc\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.78087956","0.7457491","0.733405","0.7281375","0.7198543","0.7198543","0.7198543","0.71389765","0.71339434","0.7059202","0.7003482","0.69429874","0.6942311","0.6911286","0.68954164","0.6894094","0.6872331","0.68667066","0.68229765","0.68118906","0.68111545","0.67984337","0.6794076","0.67754465","0.6756217","0.67495537","0.67465556","0.6715992","0.6697993","0.6669996","0.6669137","0.6652518","0.66512626","0.6636772","0.6631023","0.66249156","0.66177285","0.6616516","0.66090703","0.6601336","0.6594527","0.6588095","0.6581196","0.6576781","0.6570882","0.6565563","0.6556489","0.6546086","0.6540922","0.65383667","0.65340364","0.65310246","0.6527235","0.65173936","0.6500413","0.64795625","0.64787084","0.6472463","0.6472121","0.64672875","0.64517796","0.6442942","0.64406365","0.6432393","0.64323914","0.64268273","0.6421646","0.64193743","0.64042735","0.64041245","0.6393789","0.63769305","0.6376441","0.6365862","0.6361218","0.63371545","0.6335754","0.6321853","0.63217586","0.6316254","0.6312646","0.63114136","0.6307719","0.6306467","0.6299589","0.6294336","0.6292141","0.6289939","0.6283494","0.6280121","0.6275849","0.62605","0.62594086","0.6258795","0.6255771","0.6254931","0.6252865","0.62480754","0.62474495","0.6245517","0.6236936"],"string":"[\n \"0.78087956\",\n \"0.7457491\",\n \"0.733405\",\n \"0.7281375\",\n \"0.7198543\",\n \"0.7198543\",\n \"0.7198543\",\n \"0.71389765\",\n \"0.71339434\",\n \"0.7059202\",\n \"0.7003482\",\n \"0.69429874\",\n \"0.6942311\",\n \"0.6911286\",\n \"0.68954164\",\n \"0.6894094\",\n \"0.6872331\",\n \"0.68667066\",\n \"0.68229765\",\n \"0.68118906\",\n \"0.68111545\",\n \"0.67984337\",\n \"0.6794076\",\n \"0.67754465\",\n \"0.6756217\",\n \"0.67495537\",\n \"0.67465556\",\n \"0.6715992\",\n \"0.6697993\",\n \"0.6669996\",\n \"0.6669137\",\n \"0.6652518\",\n \"0.66512626\",\n \"0.6636772\",\n \"0.6631023\",\n \"0.66249156\",\n \"0.66177285\",\n \"0.6616516\",\n \"0.66090703\",\n \"0.6601336\",\n \"0.6594527\",\n \"0.6588095\",\n \"0.6581196\",\n \"0.6576781\",\n \"0.6570882\",\n \"0.6565563\",\n \"0.6556489\",\n \"0.6546086\",\n \"0.6540922\",\n \"0.65383667\",\n \"0.65340364\",\n \"0.65310246\",\n \"0.6527235\",\n \"0.65173936\",\n \"0.6500413\",\n \"0.64795625\",\n \"0.64787084\",\n \"0.6472463\",\n \"0.6472121\",\n \"0.64672875\",\n \"0.64517796\",\n \"0.6442942\",\n \"0.64406365\",\n \"0.6432393\",\n \"0.64323914\",\n \"0.64268273\",\n \"0.6421646\",\n \"0.64193743\",\n \"0.64042735\",\n \"0.64041245\",\n \"0.6393789\",\n \"0.63769305\",\n \"0.6376441\",\n \"0.6365862\",\n \"0.6361218\",\n \"0.63371545\",\n \"0.6335754\",\n \"0.6321853\",\n \"0.63217586\",\n \"0.6316254\",\n \"0.6312646\",\n \"0.63114136\",\n \"0.6307719\",\n \"0.6306467\",\n \"0.6299589\",\n \"0.6294336\",\n \"0.6292141\",\n \"0.6289939\",\n \"0.6283494\",\n \"0.6280121\",\n \"0.6275849\",\n \"0.62605\",\n \"0.62594086\",\n \"0.6258795\",\n \"0.6255771\",\n \"0.6254931\",\n \"0.6252865\",\n \"0.62480754\",\n \"0.62474495\",\n \"0.6245517\",\n \"0.6236936\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20191,"cells":{"query":{"kind":"string","value":"Attach a text label above each bar in rects, displaying its height."},"document":{"kind":"string","value":"def autolabel(rects, r, p):\n for j in range(len(rects)):\n rect = rects[j]\n height = rect.get_width()\n # print(\"height: \", height)\n ax.annotate( \"F1: \" + '{}'.format(height) + \" (P: \" + str(p[j]) + \"; R: \" + str(r[j]) + \")\",\n xy=(height, rect.get_y() + rect.get_height() / 2),\n xytext=(90, -9), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', fontsize=15)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def autolabel(rects, ax):\n global BAR_NUMBER_SIZE\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2.,\n height,\n str(round(height, 1)),\n ha ='center',\n va ='bottom',\n size = 8)","def autolabel(rects): #source: [.........]\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n '%d' % height.round(1),\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., height,\n \"{:.3f}\".format(height),\n ha='center', va='bottom')","def autolabel_bar(ax, rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2, height,\n '%.2f' % rect.get_height(),\n ha='center', va='bottom', weight='bold', size='xx-small')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n # ax.text(rect.get_x() + rect.get_width() / 2., 1.05 * height,\n # '%d' % int(height),\n # ha='center', va='bottom')","def attach_text_labels(rects, axes):\n\n for rect in rects:\n height = rect.get_height()\n label = \"{}\".format(height)\n axes.annotate(label,\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3),\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, text, extra_height=0):\n for index, rect in enumerate(rects):\n\n height = rect.get_height()\n if extra_height != 0 and index == 2:\n extra_height = 0.5\n if extra_height != 0 and index == 0:\n extra_height = 2.5\n\n plt.text(rect.get_x() + rect.get_width() / 2., height + 4 + extra_height,\n text,\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n # ax.text(rect.get_x() + rect.get_width() / 2., 1.22 * height,\n # '%d' % int(height),\n # ha='center', va='bottom')","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.text(rect.get_x() + rect.get_width()/2., 1.0*height, '%d' % int(height), ha='center', va='bottom')","def autolabel(rects, ax):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()*0.5, 0.25*height,\n '%.3g' % height,\n ha='center', va='bottom')","def AutoLabel(rects, ax):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n \"%d \" % int(height),\n ha=\"center\", va=\"bottom\")","def __autolabel(ax, rects):\n for rect in rects:\n height = rect.get_height()\n if math.isnan(height):\n continue\n w = rect.get_x() + rect.get_width()/2.\n ax.text(w, 1.05*height,\n '%d' % int(height),\n ha='center', va='bottom', fontsize='x-large')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n '%.2f' % height,\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., height + 5,\n '%d' % int(height),\n ha='center', va='bottom',\n rotation=\"vertical\", fontsize=6)","def autolabel(rects, ax):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.text(rect.get_x() + rect.get_width()/2, (height+0.2),\r\n '%.1f' % height,\r\n ha='center', va='bottom', fontsize=12)","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\r\n '%d' % int(height),\r\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., height+30,\n '%d%s' % (int(height),'%'),ha='center', va='bottom',size='smaller',color='k')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n '%d' % int(height),\n ha='center', va='bottom')","def autolabel(ax, rects):\n for rect in rects:\n height = rect.get_height()\n if height > 90:\n factor_text = 0.8\n else:\n factor_text = 1.05\n ax.text(\n rect.get_x() + rect.get_width() / 2.0,\n (factor_text * height),\n f\"{height}\",\n ha=\"center\",\n va=\"bottom\",\n fontsize=32,\n )","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n '%d' % int(height),\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n plt.text(rect.get_x() + rect.get_width()/2., 1*height,\n '%d' % int(height),\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.text(\n rect.get_x() + rect.get_width() / 2.,\n 1.005 * height,\n '%.1f' % height,\n ha='center',\n va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n plt.text(rect.get_x() + rect.get_width() / 2., 1.0 * height,\n '%d' % int(height),\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n height = np.round(height, 3)\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom',\n fontsize=20)","def autolabel(rects):\n\t for rect in rects:\n\t\theight = rect.get_height()\n\t\tax.text(rect.get_x() + rect.get_width()/2., 1.01*height,\n\t\t '%d' % int(height),\n\t\t ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n pyplot.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, -75), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', rotation=90)","def autolabel_heights(self, ax, rects, rotation: int = 0):\n y_offset = 3 if rotation == 0 else 10\n for rect in rects:\n height = rect.get_height()\n if height == 0:\n continue\n\n ax.annotate(\n '{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, y_offset), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center',\n va='bottom',\n rotation=rotation)","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate(\"%.2f\"%(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', fontsize=7)","def autolabel(ax, rects):\n # attach some text labels\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\n '%.3f' % height,\n ha='center', va='bottom')","def autolabel(ax, bars):\n for bar in bars:\n height = bar.get_height()\n ax.annotate('{:.1f}'.format(height),\n xy=(bar.get_x() + bar.get_width() / 3, height),\n xytext=(5, 5), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom',\n fontsize=20)","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(np.round(height, 2)),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = float(\"%.3f\" % (rect.get_height()))\n ax.annotate(\n \"{}\".format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha=\"center\",\n va=\"bottom\",\n )","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{0:.2f}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ylim):\n for rect in rects:\n height = rect.get_height()\n label_y = 1.05 * height if 1.10 * height < ylim else 0.75 * ylim\n ax.text(rect.get_x() + rect.get_width()/2., label_y,\n '%d' % int(height),\n ha='center', va='bottom',\n rotation='vertical')","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.annotate('{}'.format(height),\r\n xy=(rect.get_x() + rect.get_width() / 2, height),\r\n xytext=(0, 3), # 3 points vertical offset\r\n textcoords=\"offset points\",\r\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax3.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 2), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ax, c):\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., height,\n \"%.2f\" % (height),\n ha='center', va='top', color = c)","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax5.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 2), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(np.around(height,2)),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.annotate('{}'.format(height),\r\n xy=(rect.get_x() + rect.get_width() / 2, height),\r\n xytext=(0, 3), # 3 points vertical offset\r\n textcoords=\"offset points\",\r\n ha='center', va='bottom')","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.annotate('{}'.format(height),\r\n xy=(rect.get_x() + rect.get_width() / 2, height),\r\n xytext=(0, 3), # 3 points vertical offset\r\n textcoords=\"offset points\",\r\n ha='center', va='bottom')","def autolabel(rects):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.annotate('{}'.format(height),\r\n xy=(rect.get_x() + rect.get_width() / 2, height),\r\n xytext=(0, 3), # 3 points vertical offset\r\n textcoords=\"offset points\",\r\n ha='center', va='bottom')","def autolabel(rects,ax):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate(\n \"{}\".format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha=\"center\",\n va=\"bottom\",\n )","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate(\n \"{}\".format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha=\"center\",\n va=\"bottom\",\n )","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{:.1f}'.format(height/1e9),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 3, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ax):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords='offset points',\n ha='center', va='bottom', color='white', size=10)","def autolabel(rects, ax):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ax):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(ax, bars):\n for bar in bars:\n height = bar.get_height()\n ax.annotate(\n \"{:.1f}\".format(height),\n xy=(bar.get_x() + bar.get_width() / 2, height),\n # 3 points vertical offset\n xytext=(0, 3),\n textcoords=\"offset points\",\n ha=\"center\",\n va=\"bottom\",\n )","def autolabel(ax, rects, thresh):\n for rect in rects:\n height = rect.get_height()\n width = rect.get_width()\n if height > thresh:\n color = \"green\"\n else:\n color = \"black\"\n\n if height != 0:\n ax.text(\n rect.get_x() + width / 2.,\n width + 1. * height,\n \"%d\" % int(height),\n ha=\"center\",\n va=\"bottom\",\n color=color,\n size=14,\n )\n return ax","def autolabel(rects):\n for rect in rects:\n\n height = rect.get_height()\n cof=0\n if(height<0):\n cof=(min_y/100.0)*5\n ax.annotate(\"%.2f\"%(height),\n xy=(rect.get_x() + rect.get_width() / 2, height+cof),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', fontsize=7)","def autolabel(rects):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3),\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(ax, rects, vals, fsize):\n for i in range(len(rects)):\n rect = rects[i]\n val = vals[i]\n# for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., 1.0*height,\n '%d' % int(val), fontsize=fsize,\n ha='center', va='bottom')","def autolabel(rects,ax):\r\n for rect in rects:\r\n height = rect.get_height()\r\n ax.annotate('{}'.format(height),\r\n xy=(rect.get_x() + rect.get_width() / 2, height),\r\n xytext=(0, 2), \r\n textcoords=\"offset points\",\r\n ha='center', va='bottom', rotation=0)","def autolabel(self, rects, counts):\n for x, rect in zip(counts, rects):\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2., height,\n 'n = ' + str(x),\n ha='center', va='bottom')","def autolabel(ps):\n for rect in ps:\n height = np.round(rect.get_height(), 2)\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects,ax,total_count=None,step=1,):\n for index in np.arange(len(rects),step=step):\n rect = rects[index]\n height = rect.get_height()\n # print height\n if not total_count is None:\n ax.text(rect.get_x() + rect.get_width()/2., 1.005*height,\n '{:}\\n({:.6f})'.format(int(height),height/float(total_count)),\n ha='center', va='bottom')\n else:\n ax.text(rect.get_x() + rect.get_width()/2., 1.005*height,\n '{:}'.format(int(height)),\n ha='center', va='bottom')","def autolabel(fig, rects):\n for rect in rects:\n height = rect.get_height()\n fig.annotate('%.2f' % height,\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects):","def autolabel(rects, ax, fprop=None):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{:.2}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', fontproperties=fprop)","def autolabel(rects, ax, fmt='{}'):\n for rect in rects:\n height = rect.get_height()\n ax.annotate(fmt.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, abs(height)),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ax):\n # Get y-axis height to calculate label position from.\n (y_bottom, y_top) = ax.get_ylim()\n y_height = y_top - y_bottom\n\n for rect in rects:\n height = rect.get_height()\n label_position = height + (y_height * 0.01)\n\n ax.text(rect.get_x() + rect.get_width() / 2., label_position,\n '%d' % int(height),\n ha='center', va='bottom')","def autolabel(rects, scale):\n\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(round(height * scale, 0)/scale),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, ax, fontsize=12):\n #for times new roman fonts, see: https://stackoverflow.com/questions/33955900/matplotlib-times-new-roman-appears-bold\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{:.2f}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n zorder=100,\n ha='center', va='bottom', fontname=\"Times New Roman\", fontsize=fontsize)","def autolabel(rects, ax, offset=0):\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2+offset, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel_horizontal(rects,ax):\n for rect in rects:\n width = rect.get_width()\n ax.text(rect.get_x() + rect.get_width()+3, rect.get_y() + rect.get_height()/2.,\n '%.2f' % width,\n ha='center', va='center', color='black', fontsize=15)","def autolabel(rects):\n #for rect in rects:\n for i in range(len(rects)):\n rect = rects[i]\n height = rect.get_height()\n ax.annotate('{}'.format(('%.2f' % (height)) + '% of\\n' + ('%d' % range_data[i].shape[0]) + ' people' ),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom')","def autolabel(rects, rotation=0):\n ax = plt.gca()\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, 0),\n xytext=(0, 3), # 3 points vertical offset\n textcoords=\"offset points\",\n ha='center', va='bottom', color=(1,1,1),\n rotation=rotation)","def autolabel(X_pos,values,height_lift):\r\n\theight= np.round(np.nan_to_num(values),2);y_pos = height_lift*height\r\n\tfor i in range(len(height)):\r\n\t\tax.text(X_pos[i],y_pos[i],'%4.2f' % height[i], ha='center', va='bottom',size=4)","def autolabel(rects,array,axis,dist):\n ctr = 0\n label_array = [EM.truncate(v*100,1) for v in array]\n for entry in range(len(label_array)):\n if(label_array[entry]>=0) and (label_array[entry]<=1):\n label_array[entry] = EM.truncate(array[entry]*100,2)\n\n\n for rect in rects:\n height = rect.get_height()\n if(axis=='1'):\n ax1.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='2'):\n ax2.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='3'):\n ax3.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n elif(axis=='4'):\n ax4.text(rect.get_x() + rect.get_width()/2., height+dist,\n label_array[ctr],fontsize=fonts[3],\n #'%d' % int(height),\n ha='center', va='bottom',rotation=90)\n ctr = ctr + 1","def autolabel(rects, n, add_value=[]):\n if rects.__len__() == add_value.__len__() and abs_val_legend:\n for rect, val in zip(rects, add_value):\n height = rect.get_height()\n if not (np.isnan(height) or height == 0):\n ax.text(rect.get_x() + rect.get_width()/2., 1.03 * height,\n ('%1.' + str(n) + 'f') % height + '\\n' + val + '',\n ha='center', va='bottom')\n else:\n for rect in rects:\n height = rect.get_height()\n if not (np.isnan(height) or height == 0):\n ax.text(rect.get_x() + rect.get_width()/2., 1.07* height,\n ('%1.' + str(n) + 'f') % height,\n ha='center', va='bottom')","def add_value_labels(ax, spacing=5):\n\n # For each bar: Place a label\n for rect in ax.patches:\n # Get X and Y placement of label from rect.\n y_value = rect.get_height()\n x_value = rect.get_x() + rect.get_width() / 2\n\n # Number of points between bar and label. Change to your liking.\n space = spacing\n # Vertical alignment for positive values\n va = 'bottom'\n\n # If value of bar is negative: Place label below bar\n if y_value < 0:\n # Invert space to place label below\n space *= -1\n # Vertically align label at top\n va = 'top'\n\n # Use Y value as label and format number with one decimal place\n label = \"{:.1f}\".format(y_value)\n\n # Create annotation\n ax.annotate(\n label, # Use `label` as label\n (x_value, y_value), # Place label at end of the bar\n xytext=(0, space), # Vertically shift label by `space`\n textcoords=\"offset points\", # Interpret `xytext` as offset in points\n ha='center', # Horizontally center label\n va=va,fontsize=10, weight='bold') # Vertically align label differently for\n # positive and negative values.","def autolabel(ax, rects, xpos='center'):\n\n xpos = xpos.lower() # normalize the case of the parameter\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\n\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\n '{}'.format(height), ha=ha[xpos], va='bottom')","def autolabel(rects, xpos='center'):\n\n xpos = xpos.lower() # normalize the case of the parameter\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\n\n for rect in rects:\n \n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\n '{}'.format(height), ha=ha[xpos], va='bottom')","def autolabel(rects, xpos='center'):\n\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0, 'right': 1, 'left': -1}\n\n for rect in rects:\n height = rect.get_height().round(2)\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(offset[xpos]*3, 3), \n textcoords=\"offset points\", \n ha=ha[xpos], va='bottom', fontsize=14)","def autolabel(rects, ax, format='{}', xpos='center'):\n\n xpos = xpos.lower() # normalize the case of the parameter\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\n\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\n format.format(height), ha=ha[xpos], va='bottom')","def autolabel(rects, xpos='center'):\n\n xpos = xpos.lower() # normalize the case of the parameter\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\n\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\n '{}'.format(height), ha=ha[xpos], va='bottom')","def add_annotations(self):\n for i in range(8):\n self.text.append(self.canvas.create_text(-self.width / 2,\n (self.width / 2) + (i * self.width),\n font=(\"Purisa\", 12), anchor=\"nw\"))\n self.canvas.itemconfig(self.text[i], text=str((i - 8) * -1))\n for i in range(8):\n self.text.append(self.canvas.create_text((self.width / 2) + (i * self.width),\n self.width * 8 + 10, font=(\"Purisa\", 12), anchor=\"nw\"))\n self.canvas.itemconfig(self.text[i + 8], text=string.ascii_lowercase[i])","def autolabel(rects, xpos='center'):\n\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\n offset = {'center': 0, 'right': 1, 'left': -1}\n\n for rect in rects:\n height = rect.get_height()\n ax.annotate('{}'.format(height),\n xy=(rect.get_x() + rect.get_width() / 2, height),\n xytext=(offset[xpos]*2, 2), # use 3 points offset\n textcoords=\"offset points\", # in both directions\n ha=ha[xpos], va='bottom')","def getVerticalLabels(labels, font, textGap):\n\n maxWidth = 0\n height = 0\n textHeight = font.getsize(\"testq\")[1]\n for label in labels:\n maxWidth = max(maxWidth, font.getsize(label)[0])\n if height > 0: height += textGap\n height += textHeight\n size = (maxWidth, height)\n textCanvas = Image.new(\"RGB\", size, WHITE)\n textdraw = ImageDraw.Draw(textCanvas)\n py = 0\n for label in labels:\n indent = (maxWidth - font.getsize(label)[0]) / 2\n textdraw.text((indent, py), label, font=font, fill=(0,0,0))\n py += textHeight + textGap\n return textCanvas.rotate(90)","def drawUI(self):\n cv2.rectangle(self.root, (0, self.height - 80), (self.width, self.height), (50, 50, 50), -1) # bar\n cv2.putText(self.root, 'Zavri s Q...', (20, self.height - 25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)","def barPlot2():\n n = 10\n X = np.arange(n)\n Y1 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)\n plt.bar(X, +Y1, facecolor='#9999ff', edgecolor='white')\n\n for x,y in zip(X,Y1):\n plt.text(x+0.2, y+0.05, '%.2f' % y, ha='center', va= 'bottom')\n\n plt.ylim(0,1.25)\n plt.show()","def autolabel(rects, ax, model_op, xpos='center', ypos = 'up'):\n\n xpos = xpos.lower() # normalize the case of the parameter\n ypos = ypos.lower()\n va = {'center': 'center', 'top': 'bottom', 'bottom': 'top'}\n ha = {'center': 'center', 'left': 'right', 'right': 'left'}\n offset = {'center': 0.5, 'top': 0.57, 'bottom': 0.43} # x_txt = x + w*off\n\n for rect, std in zip(rects, model_op['std'].values):\n width = rect.get_width()\n ax.text(1.01 * width, rect.get_y() + rect.get_height() * offset[ypos],\n '{0:.2f}'.format(round(width,2)) + u'\\u00b1' + '{0:.2f}'.format(round(std,2)),\n va=va[ypos], ha=ha[xpos], rotation=0)","def stat_display_labels(parent, text, labels, row=0, column=0, columnspan=1):\n\n frame = tk.LabelFrame(parent, text=text, padx=5, pady=5)\n frame.grid(\n row=row, column=column, padx=5, pady=5, sticky=\"w\", columnspan=columnspan\n )\n stats_label = tk.Label(frame, text=\"\\n\".join(labels), justify=\"right\")\n stats_label.grid(row=0, column=0)\n return frame","def draw_bar(t, height):\n t.begin_fill() # Added this line\n t.left(90)\n t.forward(height)\n # t.write(\" \"+ str(height))\n t.right(90)\n t.forward(10)\n t.right(90)\n t.forward(height)\n t.left(90)\n t.end_fill() # Added this line\n t.forward(10)","def subplotLabel(axs):\n for ii, ax in enumerate(axs):\n ax.text(-0.2, 1.2, ascii_uppercase[ii], transform=ax.transAxes, fontsize=16, fontweight=\"bold\", va=\"top\")"],"string":"[\n \"def autolabel(rects, ax):\\n global BAR_NUMBER_SIZE\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2.,\\n height,\\n str(round(height, 1)),\\n ha ='center',\\n va ='bottom',\\n size = 8)\",\n \"def autolabel(rects): #source: [.........]\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n '%d' % height.round(1),\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., height,\\n \\\"{:.3f}\\\".format(height),\\n ha='center', va='bottom')\",\n \"def autolabel_bar(ax, rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2, height,\\n '%.2f' % rect.get_height(),\\n ha='center', va='bottom', weight='bold', size='xx-small')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n # ax.text(rect.get_x() + rect.get_width() / 2., 1.05 * height,\\n # '%d' % int(height),\\n # ha='center', va='bottom')\",\n \"def attach_text_labels(rects, axes):\\n\\n for rect in rects:\\n height = rect.get_height()\\n label = \\\"{}\\\".format(height)\\n axes.annotate(label,\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3),\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, text, extra_height=0):\\n for index, rect in enumerate(rects):\\n\\n height = rect.get_height()\\n if extra_height != 0 and index == 2:\\n extra_height = 0.5\\n if extra_height != 0 and index == 0:\\n extra_height = 2.5\\n\\n plt.text(rect.get_x() + rect.get_width() / 2., height + 4 + extra_height,\\n text,\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n # ax.text(rect.get_x() + rect.get_width() / 2., 1.22 * height,\\n # '%d' % int(height),\\n # ha='center', va='bottom')\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.text(rect.get_x() + rect.get_width()/2., 1.0*height, '%d' % int(height), ha='center', va='bottom')\",\n \"def autolabel(rects, ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()*0.5, 0.25*height,\\n '%.3g' % height,\\n ha='center', va='bottom')\",\n \"def AutoLabel(rects, ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n \\\"%d \\\" % int(height),\\n ha=\\\"center\\\", va=\\\"bottom\\\")\",\n \"def __autolabel(ax, rects):\\n for rect in rects:\\n height = rect.get_height()\\n if math.isnan(height):\\n continue\\n w = rect.get_x() + rect.get_width()/2.\\n ax.text(w, 1.05*height,\\n '%d' % int(height),\\n ha='center', va='bottom', fontsize='x-large')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n '%.2f' % height,\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., height + 5,\\n '%d' % int(height),\\n ha='center', va='bottom',\\n rotation=\\\"vertical\\\", fontsize=6)\",\n \"def autolabel(rects, ax):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.text(rect.get_x() + rect.get_width()/2, (height+0.2),\\r\\n '%.1f' % height,\\r\\n ha='center', va='bottom', fontsize=12)\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\r\\n '%d' % int(height),\\r\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., height+30,\\n '%d%s' % (int(height),'%'),ha='center', va='bottom',size='smaller',color='k')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n '%d' % int(height),\\n ha='center', va='bottom')\",\n \"def autolabel(ax, rects):\\n for rect in rects:\\n height = rect.get_height()\\n if height > 90:\\n factor_text = 0.8\\n else:\\n factor_text = 1.05\\n ax.text(\\n rect.get_x() + rect.get_width() / 2.0,\\n (factor_text * height),\\n f\\\"{height}\\\",\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n fontsize=32,\\n )\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n '%d' % int(height),\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n plt.text(rect.get_x() + rect.get_width()/2., 1*height,\\n '%d' % int(height),\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(\\n rect.get_x() + rect.get_width() / 2.,\\n 1.005 * height,\\n '%.1f' % height,\\n ha='center',\\n va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n plt.text(rect.get_x() + rect.get_width() / 2., 1.0 * height,\\n '%d' % int(height),\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n height = np.round(height, 3)\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom',\\n fontsize=20)\",\n \"def autolabel(rects):\\n\\t for rect in rects:\\n\\t\\theight = rect.get_height()\\n\\t\\tax.text(rect.get_x() + rect.get_width()/2., 1.01*height,\\n\\t\\t '%d' % int(height),\\n\\t\\t ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n pyplot.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, -75), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom', rotation=90)\",\n \"def autolabel_heights(self, ax, rects, rotation: int = 0):\\n y_offset = 3 if rotation == 0 else 10\\n for rect in rects:\\n height = rect.get_height()\\n if height == 0:\\n continue\\n\\n ax.annotate(\\n '{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, y_offset), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center',\\n va='bottom',\\n rotation=rotation)\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate(\\\"%.2f\\\"%(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom', fontsize=7)\",\n \"def autolabel(ax, rects):\\n # attach some text labels\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.05*height,\\n '%.3f' % height,\\n ha='center', va='bottom')\",\n \"def autolabel(ax, bars):\\n for bar in bars:\\n height = bar.get_height()\\n ax.annotate('{:.1f}'.format(height),\\n xy=(bar.get_x() + bar.get_width() / 3, height),\\n xytext=(5, 5), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom',\\n fontsize=20)\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(np.round(height, 2)),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = float(\\\"%.3f\\\" % (rect.get_height()))\\n ax.annotate(\\n \\\"{}\\\".format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n )\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{0:.2f}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ylim):\\n for rect in rects:\\n height = rect.get_height()\\n label_y = 1.05 * height if 1.10 * height < ylim else 0.75 * ylim\\n ax.text(rect.get_x() + rect.get_width()/2., label_y,\\n '%d' % int(height),\\n ha='center', va='bottom',\\n rotation='vertical')\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.annotate('{}'.format(height),\\r\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\r\\n xytext=(0, 3), # 3 points vertical offset\\r\\n textcoords=\\\"offset points\\\",\\r\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax3.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 2), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ax, c):\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., height,\\n \\\"%.2f\\\" % (height),\\n ha='center', va='top', color = c)\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax5.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 2), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(np.around(height,2)),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.annotate('{}'.format(height),\\r\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\r\\n xytext=(0, 3), # 3 points vertical offset\\r\\n textcoords=\\\"offset points\\\",\\r\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.annotate('{}'.format(height),\\r\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\r\\n xytext=(0, 3), # 3 points vertical offset\\r\\n textcoords=\\\"offset points\\\",\\r\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.annotate('{}'.format(height),\\r\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\r\\n xytext=(0, 3), # 3 points vertical offset\\r\\n textcoords=\\\"offset points\\\",\\r\\n ha='center', va='bottom')\",\n \"def autolabel(rects,ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate(\\n \\\"{}\\\".format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n )\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate(\\n \\\"{}\\\".format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n )\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{:.1f}'.format(height/1e9),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 3, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords='offset points',\\n ha='center', va='bottom', color='white', size=10)\",\n \"def autolabel(rects, ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ax):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(ax, bars):\\n for bar in bars:\\n height = bar.get_height()\\n ax.annotate(\\n \\\"{:.1f}\\\".format(height),\\n xy=(bar.get_x() + bar.get_width() / 2, height),\\n # 3 points vertical offset\\n xytext=(0, 3),\\n textcoords=\\\"offset points\\\",\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n )\",\n \"def autolabel(ax, rects, thresh):\\n for rect in rects:\\n height = rect.get_height()\\n width = rect.get_width()\\n if height > thresh:\\n color = \\\"green\\\"\\n else:\\n color = \\\"black\\\"\\n\\n if height != 0:\\n ax.text(\\n rect.get_x() + width / 2.,\\n width + 1. * height,\\n \\\"%d\\\" % int(height),\\n ha=\\\"center\\\",\\n va=\\\"bottom\\\",\\n color=color,\\n size=14,\\n )\\n return ax\",\n \"def autolabel(rects):\\n for rect in rects:\\n\\n height = rect.get_height()\\n cof=0\\n if(height<0):\\n cof=(min_y/100.0)*5\\n ax.annotate(\\\"%.2f\\\"%(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height+cof),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom', fontsize=7)\",\n \"def autolabel(rects):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3),\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(ax, rects, vals, fsize):\\n for i in range(len(rects)):\\n rect = rects[i]\\n val = vals[i]\\n# for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., 1.0*height,\\n '%d' % int(val), fontsize=fsize,\\n ha='center', va='bottom')\",\n \"def autolabel(rects,ax):\\r\\n for rect in rects:\\r\\n height = rect.get_height()\\r\\n ax.annotate('{}'.format(height),\\r\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\r\\n xytext=(0, 2), \\r\\n textcoords=\\\"offset points\\\",\\r\\n ha='center', va='bottom', rotation=0)\",\n \"def autolabel(self, rects, counts):\\n for x, rect in zip(counts, rects):\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()/2., height,\\n 'n = ' + str(x),\\n ha='center', va='bottom')\",\n \"def autolabel(ps):\\n for rect in ps:\\n height = np.round(rect.get_height(), 2)\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects,ax,total_count=None,step=1,):\\n for index in np.arange(len(rects),step=step):\\n rect = rects[index]\\n height = rect.get_height()\\n # print height\\n if not total_count is None:\\n ax.text(rect.get_x() + rect.get_width()/2., 1.005*height,\\n '{:}\\\\n({:.6f})'.format(int(height),height/float(total_count)),\\n ha='center', va='bottom')\\n else:\\n ax.text(rect.get_x() + rect.get_width()/2., 1.005*height,\\n '{:}'.format(int(height)),\\n ha='center', va='bottom')\",\n \"def autolabel(fig, rects):\\n for rect in rects:\\n height = rect.get_height()\\n fig.annotate('%.2f' % height,\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects):\",\n \"def autolabel(rects, ax, fprop=None):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{:.2}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom', fontproperties=fprop)\",\n \"def autolabel(rects, ax, fmt='{}'):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate(fmt.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, abs(height)),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ax):\\n # Get y-axis height to calculate label position from.\\n (y_bottom, y_top) = ax.get_ylim()\\n y_height = y_top - y_bottom\\n\\n for rect in rects:\\n height = rect.get_height()\\n label_position = height + (y_height * 0.01)\\n\\n ax.text(rect.get_x() + rect.get_width() / 2., label_position,\\n '%d' % int(height),\\n ha='center', va='bottom')\",\n \"def autolabel(rects, scale):\\n\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(round(height * scale, 0)/scale),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, ax, fontsize=12):\\n #for times new roman fonts, see: https://stackoverflow.com/questions/33955900/matplotlib-times-new-roman-appears-bold\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{:.2f}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n zorder=100,\\n ha='center', va='bottom', fontname=\\\"Times New Roman\\\", fontsize=fontsize)\",\n \"def autolabel(rects, ax, offset=0):\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2+offset, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel_horizontal(rects,ax):\\n for rect in rects:\\n width = rect.get_width()\\n ax.text(rect.get_x() + rect.get_width()+3, rect.get_y() + rect.get_height()/2.,\\n '%.2f' % width,\\n ha='center', va='center', color='black', fontsize=15)\",\n \"def autolabel(rects):\\n #for rect in rects:\\n for i in range(len(rects)):\\n rect = rects[i]\\n height = rect.get_height()\\n ax.annotate('{}'.format(('%.2f' % (height)) + '% of\\\\n' + ('%d' % range_data[i].shape[0]) + ' people' ),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom')\",\n \"def autolabel(rects, rotation=0):\\n ax = plt.gca()\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, 0),\\n xytext=(0, 3), # 3 points vertical offset\\n textcoords=\\\"offset points\\\",\\n ha='center', va='bottom', color=(1,1,1),\\n rotation=rotation)\",\n \"def autolabel(X_pos,values,height_lift):\\r\\n\\theight= np.round(np.nan_to_num(values),2);y_pos = height_lift*height\\r\\n\\tfor i in range(len(height)):\\r\\n\\t\\tax.text(X_pos[i],y_pos[i],'%4.2f' % height[i], ha='center', va='bottom',size=4)\",\n \"def autolabel(rects,array,axis,dist):\\n ctr = 0\\n label_array = [EM.truncate(v*100,1) for v in array]\\n for entry in range(len(label_array)):\\n if(label_array[entry]>=0) and (label_array[entry]<=1):\\n label_array[entry] = EM.truncate(array[entry]*100,2)\\n\\n\\n for rect in rects:\\n height = rect.get_height()\\n if(axis=='1'):\\n ax1.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='2'):\\n ax2.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='3'):\\n ax3.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n elif(axis=='4'):\\n ax4.text(rect.get_x() + rect.get_width()/2., height+dist,\\n label_array[ctr],fontsize=fonts[3],\\n #'%d' % int(height),\\n ha='center', va='bottom',rotation=90)\\n ctr = ctr + 1\",\n \"def autolabel(rects, n, add_value=[]):\\n if rects.__len__() == add_value.__len__() and abs_val_legend:\\n for rect, val in zip(rects, add_value):\\n height = rect.get_height()\\n if not (np.isnan(height) or height == 0):\\n ax.text(rect.get_x() + rect.get_width()/2., 1.03 * height,\\n ('%1.' + str(n) + 'f') % height + '\\\\n' + val + '',\\n ha='center', va='bottom')\\n else:\\n for rect in rects:\\n height = rect.get_height()\\n if not (np.isnan(height) or height == 0):\\n ax.text(rect.get_x() + rect.get_width()/2., 1.07* height,\\n ('%1.' + str(n) + 'f') % height,\\n ha='center', va='bottom')\",\n \"def add_value_labels(ax, spacing=5):\\n\\n # For each bar: Place a label\\n for rect in ax.patches:\\n # Get X and Y placement of label from rect.\\n y_value = rect.get_height()\\n x_value = rect.get_x() + rect.get_width() / 2\\n\\n # Number of points between bar and label. Change to your liking.\\n space = spacing\\n # Vertical alignment for positive values\\n va = 'bottom'\\n\\n # If value of bar is negative: Place label below bar\\n if y_value < 0:\\n # Invert space to place label below\\n space *= -1\\n # Vertically align label at top\\n va = 'top'\\n\\n # Use Y value as label and format number with one decimal place\\n label = \\\"{:.1f}\\\".format(y_value)\\n\\n # Create annotation\\n ax.annotate(\\n label, # Use `label` as label\\n (x_value, y_value), # Place label at end of the bar\\n xytext=(0, space), # Vertically shift label by `space`\\n textcoords=\\\"offset points\\\", # Interpret `xytext` as offset in points\\n ha='center', # Horizontally center label\\n va=va,fontsize=10, weight='bold') # Vertically align label differently for\\n # positive and negative values.\",\n \"def autolabel(ax, rects, xpos='center'):\\n\\n xpos = xpos.lower() # normalize the case of the parameter\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\\n\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\\n '{}'.format(height), ha=ha[xpos], va='bottom')\",\n \"def autolabel(rects, xpos='center'):\\n\\n xpos = xpos.lower() # normalize the case of the parameter\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\\n\\n for rect in rects:\\n \\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\\n '{}'.format(height), ha=ha[xpos], va='bottom')\",\n \"def autolabel(rects, xpos='center'):\\n\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0, 'right': 1, 'left': -1}\\n\\n for rect in rects:\\n height = rect.get_height().round(2)\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(offset[xpos]*3, 3), \\n textcoords=\\\"offset points\\\", \\n ha=ha[xpos], va='bottom', fontsize=14)\",\n \"def autolabel(rects, ax, format='{}', xpos='center'):\\n\\n xpos = xpos.lower() # normalize the case of the parameter\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\\n\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\\n format.format(height), ha=ha[xpos], va='bottom')\",\n \"def autolabel(rects, xpos='center'):\\n\\n xpos = xpos.lower() # normalize the case of the parameter\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0.5, 'right': 0.57, 'left': 0.43} # x_txt = x + w*off\\n\\n for rect in rects:\\n height = rect.get_height()\\n ax.text(rect.get_x() + rect.get_width()*offset[xpos], 1.01*height,\\n '{}'.format(height), ha=ha[xpos], va='bottom')\",\n \"def add_annotations(self):\\n for i in range(8):\\n self.text.append(self.canvas.create_text(-self.width / 2,\\n (self.width / 2) + (i * self.width),\\n font=(\\\"Purisa\\\", 12), anchor=\\\"nw\\\"))\\n self.canvas.itemconfig(self.text[i], text=str((i - 8) * -1))\\n for i in range(8):\\n self.text.append(self.canvas.create_text((self.width / 2) + (i * self.width),\\n self.width * 8 + 10, font=(\\\"Purisa\\\", 12), anchor=\\\"nw\\\"))\\n self.canvas.itemconfig(self.text[i + 8], text=string.ascii_lowercase[i])\",\n \"def autolabel(rects, xpos='center'):\\n\\n ha = {'center': 'center', 'right': 'left', 'left': 'right'}\\n offset = {'center': 0, 'right': 1, 'left': -1}\\n\\n for rect in rects:\\n height = rect.get_height()\\n ax.annotate('{}'.format(height),\\n xy=(rect.get_x() + rect.get_width() / 2, height),\\n xytext=(offset[xpos]*2, 2), # use 3 points offset\\n textcoords=\\\"offset points\\\", # in both directions\\n ha=ha[xpos], va='bottom')\",\n \"def getVerticalLabels(labels, font, textGap):\\n\\n maxWidth = 0\\n height = 0\\n textHeight = font.getsize(\\\"testq\\\")[1]\\n for label in labels:\\n maxWidth = max(maxWidth, font.getsize(label)[0])\\n if height > 0: height += textGap\\n height += textHeight\\n size = (maxWidth, height)\\n textCanvas = Image.new(\\\"RGB\\\", size, WHITE)\\n textdraw = ImageDraw.Draw(textCanvas)\\n py = 0\\n for label in labels:\\n indent = (maxWidth - font.getsize(label)[0]) / 2\\n textdraw.text((indent, py), label, font=font, fill=(0,0,0))\\n py += textHeight + textGap\\n return textCanvas.rotate(90)\",\n \"def drawUI(self):\\n cv2.rectangle(self.root, (0, self.height - 80), (self.width, self.height), (50, 50, 50), -1) # bar\\n cv2.putText(self.root, 'Zavri s Q...', (20, self.height - 25), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1, cv2.LINE_AA)\",\n \"def barPlot2():\\n n = 10\\n X = np.arange(n)\\n Y1 = (1-X/float(n)) * np.random.uniform(0.5,1.0,n)\\n plt.bar(X, +Y1, facecolor='#9999ff', edgecolor='white')\\n\\n for x,y in zip(X,Y1):\\n plt.text(x+0.2, y+0.05, '%.2f' % y, ha='center', va= 'bottom')\\n\\n plt.ylim(0,1.25)\\n plt.show()\",\n \"def autolabel(rects, ax, model_op, xpos='center', ypos = 'up'):\\n\\n xpos = xpos.lower() # normalize the case of the parameter\\n ypos = ypos.lower()\\n va = {'center': 'center', 'top': 'bottom', 'bottom': 'top'}\\n ha = {'center': 'center', 'left': 'right', 'right': 'left'}\\n offset = {'center': 0.5, 'top': 0.57, 'bottom': 0.43} # x_txt = x + w*off\\n\\n for rect, std in zip(rects, model_op['std'].values):\\n width = rect.get_width()\\n ax.text(1.01 * width, rect.get_y() + rect.get_height() * offset[ypos],\\n '{0:.2f}'.format(round(width,2)) + u'\\\\u00b1' + '{0:.2f}'.format(round(std,2)),\\n va=va[ypos], ha=ha[xpos], rotation=0)\",\n \"def stat_display_labels(parent, text, labels, row=0, column=0, columnspan=1):\\n\\n frame = tk.LabelFrame(parent, text=text, padx=5, pady=5)\\n frame.grid(\\n row=row, column=column, padx=5, pady=5, sticky=\\\"w\\\", columnspan=columnspan\\n )\\n stats_label = tk.Label(frame, text=\\\"\\\\n\\\".join(labels), justify=\\\"right\\\")\\n stats_label.grid(row=0, column=0)\\n return frame\",\n \"def draw_bar(t, height):\\n t.begin_fill() # Added this line\\n t.left(90)\\n t.forward(height)\\n # t.write(\\\" \\\"+ str(height))\\n t.right(90)\\n t.forward(10)\\n t.right(90)\\n t.forward(height)\\n t.left(90)\\n t.end_fill() # Added this line\\n t.forward(10)\",\n \"def subplotLabel(axs):\\n for ii, ax in enumerate(axs):\\n ax.text(-0.2, 1.2, ascii_uppercase[ii], transform=ax.transAxes, fontsize=16, fontweight=\\\"bold\\\", va=\\\"top\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.807113","0.79336554","0.7861467","0.7835557","0.7822906","0.77769476","0.7776375","0.7745001","0.7730597","0.7730573","0.7708679","0.77040344","0.7690377","0.7677892","0.76754576","0.76730984","0.76562864","0.7648832","0.7645011","0.7640306","0.76307166","0.76046956","0.75935924","0.7584293","0.7583782","0.7559714","0.7480944","0.74619603","0.7454694","0.74375594","0.7421532","0.7419154","0.74096423","0.74053675","0.7395104","0.73941106","0.73910624","0.7385536","0.73785794","0.737723","0.7365519","0.7365519","0.7365519","0.7365519","0.73654854","0.73654854","0.73654854","0.7360457","0.73544943","0.73544943","0.73536825","0.7351217","0.7351217","0.7351217","0.7351217","0.7351217","0.7351217","0.7351217","0.73424345","0.7333629","0.7326828","0.7326828","0.7316663","0.7298067","0.7276161","0.7274236","0.72647935","0.7260917","0.7219177","0.7195712","0.7195695","0.7195655","0.7145975","0.7144318","0.71108353","0.7109291","0.7043364","0.6981907","0.6960407","0.69353414","0.69028556","0.6836462","0.66919726","0.6654711","0.65831035","0.6577919","0.63006145","0.6241199","0.61822736","0.6153809","0.6148378","0.61444855","0.6140762","0.60102195","0.59365153","0.5921276","0.59200263","0.5911303","0.590813","0.5906624"],"string":"[\n \"0.807113\",\n \"0.79336554\",\n \"0.7861467\",\n \"0.7835557\",\n \"0.7822906\",\n \"0.77769476\",\n \"0.7776375\",\n \"0.7745001\",\n \"0.7730597\",\n \"0.7730573\",\n \"0.7708679\",\n \"0.77040344\",\n \"0.7690377\",\n \"0.7677892\",\n \"0.76754576\",\n \"0.76730984\",\n \"0.76562864\",\n \"0.7648832\",\n \"0.7645011\",\n \"0.7640306\",\n \"0.76307166\",\n \"0.76046956\",\n \"0.75935924\",\n \"0.7584293\",\n \"0.7583782\",\n \"0.7559714\",\n \"0.7480944\",\n \"0.74619603\",\n \"0.7454694\",\n \"0.74375594\",\n \"0.7421532\",\n \"0.7419154\",\n \"0.74096423\",\n \"0.74053675\",\n \"0.7395104\",\n \"0.73941106\",\n \"0.73910624\",\n \"0.7385536\",\n \"0.73785794\",\n \"0.737723\",\n \"0.7365519\",\n \"0.7365519\",\n \"0.7365519\",\n \"0.7365519\",\n \"0.73654854\",\n \"0.73654854\",\n \"0.73654854\",\n \"0.7360457\",\n \"0.73544943\",\n \"0.73544943\",\n \"0.73536825\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.7351217\",\n \"0.73424345\",\n \"0.7333629\",\n \"0.7326828\",\n \"0.7326828\",\n \"0.7316663\",\n \"0.7298067\",\n \"0.7276161\",\n \"0.7274236\",\n \"0.72647935\",\n \"0.7260917\",\n \"0.7219177\",\n \"0.7195712\",\n \"0.7195695\",\n \"0.7195655\",\n \"0.7145975\",\n \"0.7144318\",\n \"0.71108353\",\n \"0.7109291\",\n \"0.7043364\",\n \"0.6981907\",\n \"0.6960407\",\n \"0.69353414\",\n \"0.69028556\",\n \"0.6836462\",\n \"0.66919726\",\n \"0.6654711\",\n \"0.65831035\",\n \"0.6577919\",\n \"0.63006145\",\n \"0.6241199\",\n \"0.61822736\",\n \"0.6153809\",\n \"0.6148378\",\n \"0.61444855\",\n \"0.6140762\",\n \"0.60102195\",\n \"0.59365153\",\n \"0.5921276\",\n \"0.59200263\",\n \"0.5911303\",\n \"0.590813\",\n \"0.5906624\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.69238454"},"document_rank":{"kind":"string","value":"80"}}},{"rowIdx":20192,"cells":{"query":{"kind":"string","value":"Override and call super. Then do the deletion."},"document":{"kind":"string","value":"async def DeleteRoutine(self, name: str):\n #okay. problem was being cased by this line.\n #the problem is, that we delete items as part of updating\n #from gitlab. And in that case, we don't want to wipe out the local config.\n #so while it may seem like we should conveniently do this, probably, we should not.\n\n #await self.delete_local_configuration_routine(name)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def delete(self):\n\n raise NotImplementedError('Must be implemented by subclasses')","def delete(self):\n raise NotImplementedError","def delete(self):\n raise NotImplementedError()","def delete(self):\n raise NotImplementedError()","def delete(self):\n ...","def delete(self):\n\n raise NotImplementedError()","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n pass","def delete(self):\n raise exceptions.NotImplemented","def __delete__(self):\n pass","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n pass","def delete(self, *args, **kwargs):\n raise NotImplementedError()","def beforeDelete(self):","def delete(self):\n\n # TODO find a way to remove this when sub-classing in HCRoot\n self.parent.del_child(self)","def delete():","def delete(self, *args, **kwargs):\n super(Image, self).delete(*args, **kwargs)","def remove(self):\r\n\t\tself._delete()","def delete(self, *args, **kwargs):\n self.file.storage.delete(self.file.name)\n super().delete(*args, **kwargs)","def delete(self, *args, **kwargs):\n self.flush_from_cache()\n self._is_deleted = True\n super().delete(*args, **kwargs)","def remove(self):","def delete(self, *args, **kwargs):\n self.delete_relatives()\n old_content = self.content\n super().delete(*args, **kwargs)\n if old_content.isOrphaned():\n old_content.delete()","def _Delete(self):\n pass","def before_delete(self, obj, st):\n pass","def delete(self, *args, **kwargs):\n self.portrait.delete()\n super(Giza, self).delete(*args, **kwargs)","def after_delete(self, obj, st):\n pass","def delete(self, *args, **kwargs):\n return 0","def delete(self):\n self.data = None","def _remove(self):\n pass","def remove(self):\n pass","def remove(self):\n pass","def remove(self):\n pass","def delete(self):\n return super(Task, self).delete(None)","def delete(self, data):\r\n pass","def process_IN_DELETE_SELF(self, event):","def force_delete(self):\n self.manager.force_delete(self)","def force_delete(self):\n self.manager.force_delete(self)","def delete(self, *args, **kwargs) -> Any:\n pass","def delete(self, obj):\n raise NotImplementedError","def remove(self):\n raise NotImplementedError","def remove(self):\n raise NotImplementedError","def delete_callback(self):\n pass","def delete(self, *args, **kwargs):\n self.image.storage.delete(self.image.name)\n delete(self.image)\n super().delete(*args, **kwargs)","def delete(self):\r\n self.domain.delete_item(self)","def handle_remove(self):\r\n self.del_common()","def before_remove(self, cls, *args, **kwargs):\n pass","def __del__(self) -> None:\n self.delete()","def onRemove(self):\n pass","def onRemove(self):\n pass","def after_remove(self, cls, *args, **kwargs):\n pass","def post_destroy(self) -> Any:\n raise NotImplementedError","def delete(self) -> None:\n self.pop()","def delete(self):\n self.manager.delete(self.name)","def delete(self):\n self.manager.delete(self.name)","def delete(self, obj):","def delete(self, *args, **kwargs):\n self.file.delete(save=False)\n self.thumbnail.delete(save=False)\n\n super(File, self).delete(*args, **kwargs)","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def delete(self):\n return self._finalize()","def pre_destroy(self) -> Any:\n raise NotImplementedError","def delete(self, _id):","def delete(self):\n self.manager.delete(self)","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def remove(self):\n self._delete()","def delete(self, *args, **kwargs):\n self.image.delete()\n super(Recipe, self).delete(*args, **kwargs)","def __on_delete(self):\n self.image.delete()","def __on_delete(self):\n self.image.delete()","def __del__(self):\n print(f\"{self.fullname()} deleted from database.\")","def delete(self):\r\n s = self.get_session()\r\n s.delete(self)\r\n s.commit()","def destroy(self):\n raise NotImplementedError()","def delete(self):\n if not self.is_deleted:\n self.is_deleted = True\n self.save()","def delete(self):\n self._instance.delete()\n self._instance = None\n self._data_defs = []","def delete(self):\n return self.parent.delete_instance(self.name)","def destroy(self):\n raise NotImplementedError('You must implement the destroy() method '\n 'yourself!')","def destroy(self):","def destroy(self):","def destroy(self):","def delete(self):\n if self.parent:\n assert isinstance(self.parent, Collection) # only know how to delete from Collection parents\n self.parent.delete_child(self)\n else:\n self._mark_deleted()","def delete(self, tree_path):\n\t\traise NotImplementedError","def prepareToDelete(self):\n pass","def delete(self, doing_import=False):\n if doing_import:\n super(CombinedTeledata, self).delete()\n else:\n raise NotImplementedError(message=\"Deleting is not possible on this method unless importing.\")"],"string":"[\n \"def delete(self):\\n\\n raise NotImplementedError('Must be implemented by subclasses')\",\n \"def delete(self):\\n raise NotImplementedError\",\n \"def delete(self):\\n raise NotImplementedError()\",\n \"def delete(self):\\n raise NotImplementedError()\",\n \"def delete(self):\\n ...\",\n \"def delete(self):\\n\\n raise NotImplementedError()\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n pass\",\n \"def delete(self):\\n raise exceptions.NotImplemented\",\n \"def __delete__(self):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n raise NotImplementedError()\",\n \"def beforeDelete(self):\",\n \"def delete(self):\\n\\n # TODO find a way to remove this when sub-classing in HCRoot\\n self.parent.del_child(self)\",\n \"def delete():\",\n \"def delete(self, *args, **kwargs):\\n super(Image, self).delete(*args, **kwargs)\",\n \"def remove(self):\\r\\n\\t\\tself._delete()\",\n \"def delete(self, *args, **kwargs):\\n self.file.storage.delete(self.file.name)\\n super().delete(*args, **kwargs)\",\n \"def delete(self, *args, **kwargs):\\n self.flush_from_cache()\\n self._is_deleted = True\\n super().delete(*args, **kwargs)\",\n \"def remove(self):\",\n \"def delete(self, *args, **kwargs):\\n self.delete_relatives()\\n old_content = self.content\\n super().delete(*args, **kwargs)\\n if old_content.isOrphaned():\\n old_content.delete()\",\n \"def _Delete(self):\\n pass\",\n \"def before_delete(self, obj, st):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n self.portrait.delete()\\n super(Giza, self).delete(*args, **kwargs)\",\n \"def after_delete(self, obj, st):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n return 0\",\n \"def delete(self):\\n self.data = None\",\n \"def _remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def remove(self):\\n pass\",\n \"def delete(self):\\n return super(Task, self).delete(None)\",\n \"def delete(self, data):\\r\\n pass\",\n \"def process_IN_DELETE_SELF(self, event):\",\n \"def force_delete(self):\\n self.manager.force_delete(self)\",\n \"def force_delete(self):\\n self.manager.force_delete(self)\",\n \"def delete(self, *args, **kwargs) -> Any:\\n pass\",\n \"def delete(self, obj):\\n raise NotImplementedError\",\n \"def remove(self):\\n raise NotImplementedError\",\n \"def remove(self):\\n raise NotImplementedError\",\n \"def delete_callback(self):\\n pass\",\n \"def delete(self, *args, **kwargs):\\n self.image.storage.delete(self.image.name)\\n delete(self.image)\\n super().delete(*args, **kwargs)\",\n \"def delete(self):\\r\\n self.domain.delete_item(self)\",\n \"def handle_remove(self):\\r\\n self.del_common()\",\n \"def before_remove(self, cls, *args, **kwargs):\\n pass\",\n \"def __del__(self) -> None:\\n self.delete()\",\n \"def onRemove(self):\\n pass\",\n \"def onRemove(self):\\n pass\",\n \"def after_remove(self, cls, *args, **kwargs):\\n pass\",\n \"def post_destroy(self) -> Any:\\n raise NotImplementedError\",\n \"def delete(self) -> None:\\n self.pop()\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def delete(self):\\n self.manager.delete(self.name)\",\n \"def delete(self, obj):\",\n \"def delete(self, *args, **kwargs):\\n self.file.delete(save=False)\\n self.thumbnail.delete(save=False)\\n\\n super(File, self).delete(*args, **kwargs)\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def delete(self):\\n return self._finalize()\",\n \"def pre_destroy(self) -> Any:\\n raise NotImplementedError\",\n \"def delete(self, _id):\",\n \"def delete(self):\\n self.manager.delete(self)\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def remove(self):\\n self._delete()\",\n \"def delete(self, *args, **kwargs):\\n self.image.delete()\\n super(Recipe, self).delete(*args, **kwargs)\",\n \"def __on_delete(self):\\n self.image.delete()\",\n \"def __on_delete(self):\\n self.image.delete()\",\n \"def __del__(self):\\n print(f\\\"{self.fullname()} deleted from database.\\\")\",\n \"def delete(self):\\r\\n s = self.get_session()\\r\\n s.delete(self)\\r\\n s.commit()\",\n \"def destroy(self):\\n raise NotImplementedError()\",\n \"def delete(self):\\n if not self.is_deleted:\\n self.is_deleted = True\\n self.save()\",\n \"def delete(self):\\n self._instance.delete()\\n self._instance = None\\n self._data_defs = []\",\n \"def delete(self):\\n return self.parent.delete_instance(self.name)\",\n \"def destroy(self):\\n raise NotImplementedError('You must implement the destroy() method '\\n 'yourself!')\",\n \"def destroy(self):\",\n \"def destroy(self):\",\n \"def destroy(self):\",\n \"def delete(self):\\n if self.parent:\\n assert isinstance(self.parent, Collection) # only know how to delete from Collection parents\\n self.parent.delete_child(self)\\n else:\\n self._mark_deleted()\",\n \"def delete(self, tree_path):\\n\\t\\traise NotImplementedError\",\n \"def prepareToDelete(self):\\n pass\",\n \"def delete(self, doing_import=False):\\n if doing_import:\\n super(CombinedTeledata, self).delete()\\n else:\\n raise NotImplementedError(message=\\\"Deleting is not possible on this method unless importing.\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.8312543","0.8277076","0.8197373","0.8197373","0.81892085","0.81146294","0.81122106","0.81122106","0.81122106","0.81122106","0.776644","0.77381533","0.76547843","0.76547843","0.7546651","0.74831843","0.7471033","0.7380182","0.73753977","0.7372484","0.73603785","0.73473245","0.73305553","0.72786963","0.72515905","0.72299075","0.72279274","0.7209575","0.7198437","0.7188262","0.7172134","0.7171383","0.7171383","0.7171383","0.7140039","0.71394694","0.7139072","0.7128609","0.7128609","0.7123742","0.7095671","0.70943725","0.70943725","0.7076313","0.7058949","0.70365804","0.7013849","0.6999841","0.6984355","0.6970105","0.6970105","0.69609153","0.6959129","0.69534683","0.6935767","0.6935767","0.69306594","0.6909545","0.6907781","0.6907781","0.6907781","0.6907781","0.6907781","0.6907781","0.6907781","0.6907781","0.6907781","0.69068885","0.689196","0.68850386","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.68785614","0.6871383","0.68416846","0.68416846","0.6828373","0.6814196","0.6799565","0.6785008","0.67842305","0.676939","0.6769342","0.67684317","0.67684317","0.67684317","0.6758636","0.6738821","0.6736349","0.67233443"],"string":"[\n \"0.8312543\",\n \"0.8277076\",\n \"0.8197373\",\n \"0.8197373\",\n \"0.81892085\",\n \"0.81146294\",\n \"0.81122106\",\n \"0.81122106\",\n \"0.81122106\",\n \"0.81122106\",\n \"0.776644\",\n \"0.77381533\",\n \"0.76547843\",\n \"0.76547843\",\n \"0.7546651\",\n \"0.74831843\",\n \"0.7471033\",\n \"0.7380182\",\n \"0.73753977\",\n \"0.7372484\",\n \"0.73603785\",\n \"0.73473245\",\n \"0.73305553\",\n \"0.72786963\",\n \"0.72515905\",\n \"0.72299075\",\n \"0.72279274\",\n \"0.7209575\",\n \"0.7198437\",\n \"0.7188262\",\n \"0.7172134\",\n \"0.7171383\",\n \"0.7171383\",\n \"0.7171383\",\n \"0.7140039\",\n \"0.71394694\",\n \"0.7139072\",\n \"0.7128609\",\n \"0.7128609\",\n \"0.7123742\",\n \"0.7095671\",\n \"0.70943725\",\n \"0.70943725\",\n \"0.7076313\",\n \"0.7058949\",\n \"0.70365804\",\n \"0.7013849\",\n \"0.6999841\",\n \"0.6984355\",\n \"0.6970105\",\n \"0.6970105\",\n \"0.69609153\",\n \"0.6959129\",\n \"0.69534683\",\n \"0.6935767\",\n \"0.6935767\",\n \"0.69306594\",\n \"0.6909545\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.6907781\",\n \"0.69068885\",\n \"0.689196\",\n \"0.68850386\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.68785614\",\n \"0.6871383\",\n \"0.68416846\",\n \"0.68416846\",\n \"0.6828373\",\n \"0.6814196\",\n \"0.6799565\",\n \"0.6785008\",\n \"0.67842305\",\n \"0.676939\",\n \"0.6769342\",\n \"0.67684317\",\n \"0.67684317\",\n \"0.67684317\",\n \"0.6758636\",\n \"0.6738821\",\n \"0.6736349\",\n \"0.67233443\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20193,"cells":{"query":{"kind":"string","value":"Deletes the local configuration for a container."},"document":{"kind":"string","value":"async def delete_local_configuration_routine(self, name: str):\n plat = get_local_platform_routines()\n user = LocalUserRoutines(plat)\n manager = LocalContainerConfigurationManager(user)\n cont = self.GetItemByName(name)\n manager.DeleteByID(cont.GetID())"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def remove_local_config(self):\n with ignored(OSError):\n os.remove(os.path.join(self.rundir, const.LOCAL_CONFIG_FILE))","def delete_container(self, container: Container):","def delete_container(self, account, container):\n \n pass","def delete_container(ContainerName=None):\n pass","async def before_cleanup(self, invoker: PluginInvoker):\n config_file = invoker.files[\"config\"]\n try:\n config_file.unlink()\n except FileNotFoundError:\n pass\n logging.debug(f\"Deleted configuration at {config_file}\")","def kubeconfig_delete(self):\n\n self._client.delete(\n \"{}/kubeconfig\".format(LKECluster.api_endpoint), model=self\n )","def clean():\n Log.d(DEBUG_TAG, \"Delete config file...\")\n try:\n os.remove(CONFIG_FILE)\n except os.error as e:\n Log.e(DEBUG_TAG, \"Delete config file%s error, reason:%s\"%(CONFIG_FILE, e))","def keystone_departed():\n with charm.provide_charm_instance() as charm_instance:\n charm_instance.remove_config()","def delete(self):\n try:\n self._client.delete_launch_configuration(LaunchConfigurationName=self._name)\n except botocore.exceptions.ClientError as e:\n if \"not found\" in e.response[\"Error\"][\"Message\"]:\n logger.warn(\"Launch configuration %s not found\", self._name)\n else:\n raise","def remove_config(name):\n db = dbm.open(config_file, 'c')\n del db[name]\n db.close()","def do_DELETE(self): # pylint: disable=C0103\r\n if self.path == \"/del_config\" or self.path == \"/del_config/\":\r\n self.server.config = dict()\r\n self.log_message(\"Reset Server Configuration.\")\r\n self.send_response(200)\r\n else:\r\n self.send_response(404)","def delete_configuration(self, node, ports):\n return hpssa_manager.delete_configuration()","def delete(configsetname):\n cnfset = configsetPath(configsetname)\n files = os.listdir(cnfset)\n for f in files: os.remove(os.path.join(cnfset, f))\n os.rmdir(cnfset)\n return None","def remove(cls, config: Dict) -> None:\n node = get_node_by_id(cls.cluster, config[\"node\"])\n id_ = config[\"id\"]\n\n cls.shell(\n args=[\"ceph\", \"auth\", \"del\", id_],\n )\n\n if config.get(\"remove_admin_keyring\"):\n node.exec_command(\n cmd=\"rm -rf /etc/ceph/ceph.client.admin.keyring\",\n sudo=True,\n )\n\n node.exec_command(\n sudo=True, cmd=f\"rm -rf /etc/ceph/ceph.{id_}.keyring\", check_ec=False\n )\n\n out, _ = node.exec_command(cmd=\"ls -ltrh /etc/ceph/\", sudo=True)\n log.info(out)\n\n # Remove packages like ceph-common\n # Be-careful it may remove entire /etc/ceph directory\n if config.get(\"remove_packages\"):\n for pkg in config.get(\"remove_packages\"):\n node.exec_command(\n cmd=f\"yum remove -y {pkg}\",\n sudo=True,\n )","def delete(self):\r\n return self.connection.delete_launch_configuration(self.name)","def delete_endpoint_config(EndpointConfigName=None):\n pass","def reset_server_configuration_fixture():\n config_instance = Configuration()\n Path(config_instance.server_config_dir, 'test-gigantum-com.json').unlink()\n Path(config_instance.server_config_dir, 'CURRENT').unlink()\n config_instance._get_redis_client().delete(config_instance.SERVER_CONFIG_CACHE_KEY,\n config_instance.AUTH_CONFIG_CACHE_KEY)\n Path(config_instance.server_data_dir, 'test-gigantum-com').rmdir()","def _destroy(self):\r\n if self._client:\r\n self._client.returnNr(self._nr)\r\n self._client.unregisterContainer(self)\r\n self._client = None\r\n\r\n if self._confDir:\r\n shutil.rmtree(self._confDir, True)\r\n self._confDir = None\r\n\r\n if self._dataDir:\r\n shutil.rmtree(self._dataDir, True)\r\n self._dataDir = None","def clean():\n local('rm -fr %s' % os.path.abspath(env.config['destination']))","def config_exit(self):\n self._master.destroy()\n self._config_status = False # ensure the world wouldn't be built","def remove_stored_config(self):\n stored_config_filename = self.stored_config_filename\n if stored_config_filename.exists():\n stored_config_filename.remove()\n self._stored_cmake_generator = self._stored_config.cmake_generator","def remove_config_object() -> None:\n if G_CONFIG_OBJECT:\n G_CONFIG_OBJECT.clear()","def delete_conf(src_ip):\n return delete_route(src_ip)","def del_conf(self, path):\n\t\tself.monitor.removePath(path)\n\t\tself.cache.pop(path, None)","def clear(self):\r\n del self.__config\r\n self.__config = {}\r\n self.save()","def delete_k8s_configuration(client, resource_group_name, cluster_name, name, cluster_type):\n # Determine ClusterRP\n cluster_rp = __get_cluster_type(cluster_type)\n\n source_control_configuration_name = name\n\n return client.delete(resource_group_name, cluster_rp, cluster_type, cluster_name, source_control_configuration_name)","def test_delete_namespaced_deployment_config(self):\n pass","def removeConfigFile(alg):\r\n configPath = alg.getParameterValue('config')\r\n if isWindows():\r\n command = \"DEL {}\".format(os.path.join(rliPath(), configPath))\r\n else:\r\n command = \"rm {}\".format(os.path.join(rliPath(), configPath))\r\n alg.commands.append(command)","def cleanup(self):\n self.qemu.clean_run_files()\n for tmp in glob.glob(self.configfile + \"?*\"):\n os.unlink(tmp)","def DeleteConfig(self, request, context):\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\n context.set_details('Method not implemented!')\n raise NotImplementedError('Method not implemented!')","def reset(args):\n if os.path.exists(args.config):\n os.remove(args.config)\n return","def remove_user_configuration(self):\n shutil.rmtree(self.test.user_conf_dir())","def reset_config():\r\n # TODO implement configuration reset\r\n pass","def do_delete_configured_volume(self, arg):\n args = self.parse_arguments(arg)\n if len(args) == 0:\n self.perror(\"No storage specified.\")\n return\n self.do_coroutine(self._localStorageRoutines.delete_configured_volume_routine(args[0]))","def docker_remove(self) -> int:\n try:\n container = self.client.containers.get(self.cname)\n except docker.errors.NotFound:\n return\n\n info(\"Removing container {}...\".format(self.cname), nl=False)\n container.remove(force=True)\n info(\"Done!\")","def remove_trap_config(self, context, storage_id, trap_config):\n # Currently not implemented\n pass","def del_cfgs (conn):\n\n try:\n csr = conn.cursor()\n\n cmd = \"DELETE FROM {tbl};\".\\\n format(tbl = _tbl_config)\n print(cmd)\n\n csr.execute(cmd)\n csr.close()\n\n except Exception as ex:\n print(\"Error - del_cfgs: {0}\".format(ex))\n rc_err = ex.args[0]\n return rc_err\n\n return rc_ok","async def websocket_lovelace_delete_config(\n hass: HomeAssistant,\n connection: websocket_api.ActiveConnection,\n msg: dict[str, Any],\n config: LovelaceStorage,\n) -> None:\n await config.async_delete()","def deleted(self, configurationId):\n log.debug('ConfigListener: configuration %s deleted' % configurationId)\n ZenProcessTask.DEVICE_STATS.pop(configurationId, None)","def delete_configs(configholder, configs):\n for config_name in configs:\n configholder.delete_config(config_name)","def destroy(self):\n logger.info(\"Removing container '%s'\", self.name)\n if not self.container.destroy():\n logger.warning(\"lxc-destroy failed, trying to remove directory\")\n # We check that LXCBASE/NAME/config exists because if it does then\n # lxc destroy should have succeeded and the failure is elsewhere,\n # for example the container is still running\n if os.path.isdir(self.containerpath) \\\n and self.containerpath.startswith(const.LXCBASE) \\\n and not os.path.exists(\n os.path.join(self.containerpath, \"config\")):\n shutil.rmtree(self.containerpath)\n else:\n raise ContainerError(\"Path doesn't exist: {}\".format(self.containerpath))\n logger.debug(\"Done\")","def rm_network(c):\n print('Stopping local test network and removing containers')\n with c.cd('images'):\n c.run('sudo docker-compose down -v', hide='stderr')\n\n c.run('sudo rm -rf volumes/stellar-core/opt/stellar-core/buckets')\n c.run('sudo rm -f volumes/stellar-core/opt/stellar-core/*.log')\n c.run('sudo rm -rf volumes/stellar-core/tmp')","def rpc_delete_config(self, unused_session, rpc, *unused_params):\n raise ncerror.OperationNotSupportedProtoError(rpc)","def clear_config():\n check_config()\n fs.truncate(PYWS_DIR_BIN)","def test_destroy_container(self):\n pass","def delete_handler(event, context):\n delete_endpoint_config(event)","def test_delete_config_root(self):\n config_root = self._create_config_root()\n config_root_uuid = config_root['config-root']['uuid']\n with self.override_role():\n self.config_client.delete_config_root(\n config_root_uuid)","def cli(ctx):\n stopped = click.style(\"Stopped\", fg=\"red\")\n removed = click.style(\"Removed\", fg=\"blue\")\n for container in ctx.docker.get_containers():\n name = container.hostname\n node_name = ''.join([i for i in name if not i.isdigit()])\n image_name = container.dictionary['Config']['Image']\n if node_name in TO_KILL:\n container.stop(timeout=0)\n else:\n container.stop(timeout=5)\n # container.execute(\"poweroff\", \"root\", \"/\", False)\n # container.wait()\n ctx.log(\"Container %s --> %s\" % (name, stopped))\n container.remove(v=False, link=False, force=True)\n ctx.log(\"Container %s --> %s\" % (name, removed))\n ctx.state['containers'].remove(container.short_id)\n ctx.state.fast_dump()\n # remove untagged image\n if not image_name.startswith(ctx.prefix):\n ctx.docker.remove_image(image_name, force=True)\n ctx.docker.remove_network()","def delete_directory_config(DirectoryName=None):\n pass","async def DeleteRoutine(self, name: str):\n #okay. problem was being cased by this line.\n #the problem is, that we delete items as part of updating\n #from gitlab. And in that case, we don't want to wipe out the local config.\n #so while it may seem like we should conveniently do this, probably, we should not.\n\n #await self.delete_local_configuration_routine(name)","def test_config_remove(self):\n server = self.start_server(\"hello world\", 200)\n try:\n self.setup_dynamic()\n\n cfg_file = \"test.yml\"\n\n self.write_dyn_config(\n cfg_file, self.http_cfg(\"myid\", \"http://localhost:{}\".format(server.server_port)))\n\n self.wait_until(lambda: self.output_has(lines=2))\n\n self.assert_last_status(\"up\")\n\n os.remove(self.monitors_dir() + cfg_file)\n\n # Ensure the job was removed from the schduler\n self.wait_until(lambda: self.log_contains(\"Remove scheduler job 'myid'\"))\n self.wait_until(lambda: self.log_contains(\"Job 'myid' returned\"))\n\n self.proc.check_kill_and_wait()\n finally:\n server.shutdown()","def remove(ctx, name, project_root):\n\n if name == 'logme':\n raise LogmeError(\"'logme' master logger configuration cannot be removed!\")\n\n with ensure_conf_exist(project_root) as logme_conf:\n\n config = read_config(logme_conf)\n config.remove_section(name)\n\n with logme_conf.open('w+') as conf:\n config.write(conf)","def delete_config_callback(self, trigger_id, config):\n self.tcex.log.trace('delete config callback')","def remove(self, container):\n pass","def delete_uptime_check_config(config_name: str) -> None:\n client = monitoring_v3.UptimeCheckServiceClient()\n client.delete_uptime_check_config(request={\"name\": config_name})\n print(\"Deleted \", config_name)","def purge_config_cache(location=None):\n\n cache_path = get_cache_path(location)\n\n if location:\n os.remove(cache_path)\n else:\n shutil.rmtree(cache_path)","def container_delete(ctx, token, container_ids, force):\n try:\n out = ctx.obj.container_delete(token, container_ids, force)\n print_message(out)\n except exceptions.DockerException as e:\n m = e.message\n print_error(m)","def test_del_empty_config():\n\n testutils.deploy_config_raw(\"\")\n\n assert prop.del_prop('info', 'sdk') != 0\n\n testutils.undeploy()\n\n return 0","def delete_notebook_instance_lifecycle_config(NotebookInstanceLifecycleConfigName=None):\n pass","def remove_pgsql_conf(self):\n self.kv.unset(\"pgsql_host\")\n self.kv.unset(\"pgsql_port\")\n self.kv.unset(\"pgsql_db\")\n self.kv.unset(\"pgsql_user\")\n self.kv.unset(\"pgsql_pass\")\n self.kv.flush()","def delete_config_set(self, req, id):\n try:\n deleted_config_set = self.db_api.config_set_destroy(\n req.context, id)\n msg = _LI(\"Successfully deleted config_set %(id)s\") % {'id': id}\n LOG.info(msg)\n return dict(config_set=deleted_config_set)\n except exception.ForbiddenPublicImage:\n msg = _LI(\"Delete denied for public config_set %(id)s\") % {\n 'id': id}\n LOG.info(msg)\n raise exc.HTTPForbidden()\n except exception.Forbidden as e:\n # If it's private and doesn't belong to them, don't let on\n # that it exists\n LOG.info(e)\n return exc.HTTPForbidden(e)\n except exception.NotFound:\n msg = _LI(\"config_set %(id)s not found\") % {'id': id}\n LOG.info(msg)\n return exc.HTTPNotFound()\n except Exception:\n LOG.exception(_LE(\"Unable to delete config_set %s\") % id)\n raise","def test_delete_global_system_config(self):\n new_config = self._create_global_system_config()\n with self.override_role():\n self.config_client.delete_global_system_config(new_config['uuid'])","def delete(self, configuration):\n configuration = g.user.get_api().get_configuration(configuration)\n configuration.delete()\n return '', 204","async def clear_config(self, ctx, guild_id: int):\n try:\n result = await db.Config.filter(guild_id=guild_id).delete()\n except Exception as e:\n result = f\"{e.__class__.__name__}: {e}\"\n db.config_cache.pop(guild_id)\n await ctx.send(f\"```py\\n{result}\\n```\")","def test_delete_namespaced_build_config(self):\n pass","def remove_config(self, config):\n for fn in config:\n try:\n os.remove(fn)\n LOGGER.debug('Removed backup: %s', fn)\n\n except IOError as e:\n if e.errno != errno.ENOENT:\n LOGGER.warning('Could not remove backup: %s', fn)","def remove_docker_compose_file():\n os.remove(DOCKER_COMPOSE_FILE)","def remove_prompt(name, delete_config):\n\n with open(DATABASE_FILE_PATH) as f:\n config = json.load(f)\n path = config[name]\n del config[name]\n\n with open(DATABASE_FILE_PATH, 'w') as f:\n json.dump(config, f)\n\n if delete_config:\n os.remove(path)","def destroy_lxd_container(container):\n\n if type(container) is bool:\n return\n\n name = container.name\n debug(\"Destroying container {}\".format(name))\n\n client = get_lxd_client()\n\n def wait_for_stop(timeout=30):\n \"\"\"Wait for eth0 to have an ipv4 address.\"\"\"\n starttime = time.time()\n while(time.time() < starttime + timeout):\n time.sleep(1)\n if container.state == \"Stopped\":\n return\n\n def wait_for_delete(timeout=30):\n starttime = time.time()\n while(time.time() < starttime + timeout):\n time.sleep(1)\n if client.containers.exists(name) is False:\n return\n\n try:\n container.stop(wait=False)\n wait_for_stop()\n except Exception as ex:\n debug(\n \"Error stopping container {}: {}\".format(\n name,\n ex,\n )\n )\n\n try:\n container.delete(wait=False)\n wait_for_delete()\n except Exception as ex:\n debug(\n \"Error deleting container {}: {}\".format(\n name,\n ex,\n )\n )\n\n try:\n # Delete the profile created for this container\n profile = client.profiles.get(name)\n if profile:\n profile.delete()\n except Exception as ex:\n debug(\n \"Error deleting profile {}: {}\".format(\n name,\n ex,\n )\n )","def unconfigure_set(cluster, cursor, name, configuration):\n logger.info('Unconfiguring replication set on %s...', cursor.connection.dsn)\n\n # Drop the transaction queue if it exists.\n logger.info('Dropping transaction queue...')\n cursor.execute(\"SELECT pgq.drop_queue(%s)\", (cluster.get_queue_name(name),))\n\n for table in configuration.tables:\n drop_trigger(cluster, cursor, name, table.schema, table.name)","def tearDown(self):\n test_utils.delete_test_config()","def delete(ctx, **_):\n # Delete the resource\n azure_config = ctx.node.properties.get('azure_config')\n if not azure_config.get(\"subscription_id\"):\n azure_config = ctx.node.properties.get('client_config')\n else:\n ctx.logger.warn(\"azure_config is deprecated please use client_config, \"\n \"in later version it will be removed\")\n resource_group_name = utils.get_resource_group(ctx)\n vm_name = ctx.instance.runtime_properties.get('virtual_machine')\n name = ctx.instance.runtime_properties.get('name')\n api_version = \\\n ctx.node.properties.get('api_version', constants.API_VER_COMPUTE)\n vm_extension = VirtualMachineExtension(azure_config, ctx.logger,\n api_version)\n utils.handle_delete(ctx, vm_extension, resource_group_name, name, vm_name)","def remove_venv_config(name: str) -> Path:\n config_file_path = find_vsh_config(name=name, check=False)\n if config_file_path.exists():\n config_file_path.unlink()\n return config_file_path","def clear(self):\n with open(self.config_file, mode='w') as f:\n data = {}\n d = json.dumps(data)\n f.write(d)","def DeleteContainers(self):\n for container in itertools.chain(*list(self.containers.values())):\n container.Delete()","def cleanup(self):\n self.exit_config_mode()","def delete(name, config, backend, storage, debug):\n setup_lithops_logger(logging.DEBUG)\n\n verify_runtime_name(name)\n\n if config:\n config = load_yaml_config(config)\n\n setup_lithops_logger(logging.DEBUG)\n\n config_ow = set_config_ow(backend, storage, runtime_name=name)\n config = default_config(config, config_ow)\n\n if config['lithops']['mode'] != SERVERLESS:\n raise Exception('\"lithops runtime delete\" command is only valid for serverless backends')\n\n storage_config = extract_storage_config(config)\n internal_storage = InternalStorage(storage_config)\n compute_config = extract_serverless_config(config)\n compute_handler = ServerlessHandler(compute_config, internal_storage)\n\n runtimes = compute_handler.list_runtimes(name)\n for runtime in runtimes:\n compute_handler.delete_runtime(runtime[0], runtime[1])\n runtime_key = compute_handler.get_runtime_key(runtime[0], runtime[1])\n internal_storage.delete_runtime_meta(runtime_key)","def test_delete_collection_namespaced_deployment_config(self):\n pass","def pytest_unconfigure(config):\n db = Graph(DEFAULT_DB)\n db.delete_all()","def rm(ws):\n ws.docker_remove()","def delete_host(self, conf, tenant_id, network_id, host_id):\n\t\tpass","def remove(self, host):\n for p, c in self.configs_:\n if host in c.hosts_:\n c.remove(host)\n return\n raise ValueError(\"Host %s: not found\" % host)","def clean_azml_workspace(ctx):\n\n ws = get_workspace(config)\n\n # remove compute clusters\n for _, compute in ws.compute_targets.items():\n if not compute.provisioning_state == \"Deleting\":\n print(f\"Deleting {compute.name}\")\n compute.delete()","def delete_configuration(ctx, name: Optional[str], assume_yes: bool):\n config_set = __ensure_configuration_exists(ctx)\n\n config = __ensure_name_in_config_set(ctx, name, config_set)\n\n # Confirm for override\n if not assume_yes:\n click.confirm(\n 'The configuration \"{}\" will be removed. Do you want to continue?'.format(config.printable_name),\n abort=True)\n\n c = config_set[name]\n config_set.remove(name)\n\n if len(config_set) == 0:\n # There are no configurations\n os.unlink(abejacli.configuration.CONFIG_FILE_PATH)\n return\n\n # Change active configuration\n if name == config_set.active_config_name:\n if name is None:\n # default configuration removed. choose the first one.\n config_set.active_config_name = next(iter(config_set)).name\n __save_config_set(config_set)\n else:\n if None in config_set:\n config_set.active_config_name = None\n else:\n config_set.active_config_name = next(iter(config_set)).name\n\n __save_config_set(config_set)\n\n click.echo('[INFO]: The configuration \"{}\" successfully deleted.'.format(\n c.printable_name))","def pre_global_vrouter_config_delete(self, resource_id):\n pass","def deconfigure(self):\n\n pass","def clean_cluster_config(self, clusterid, config, **kwargs):\n pass","def clean_config(job_cfg_path, fixtures_path):\n tree = ET.parse(job_cfg_path)\n root = tree.getroot()\n inject_tree = ET.parse(fixtures_path)\n for node in inject_tree.getroot():\n srcnode = root.find(\"./%s\" % node.tag)\n if srcnode is not None:\n root.remove(srcnode)\n tree.write(job_cfg_path)","def deconfigure(self):\n\n self.platform.deconfigure()","def test_delete_hyperflex_vcenter_config_policy(self):\n pass","def pre_global_system_config_delete(self, resource_id):\n pass","def clean_docker(c):\n c.run(f'docker image rm -f $(docker image ls --filter reference={docker_repo} -q) || true')","def cleanup_infrastructure_storage(config, datacenter):\n print \"Removing storage devices in datacenter %s...\" % datacenter.getName()\n for device in datacenter.listStorageDevices():\n device.delete()","def test_delete_config_node(self):\n config_node = self._create_config_node()\n config_node_uuid = config_node['config-node']['uuid']\n with self.override_role():\n self.config_client.delete_config_node(\n config_node_uuid)","def docker_rm(args, container_id): # type: (EnvironmentConfig, str) -> None\n try:\n docker_command(args, ['rm', '-f', container_id], capture=True)\n except SubprocessError as ex:\n if 'no such container' in ex.stderr:\n pass # podman does not handle this gracefully, exits 1\n else:\n raise ex","def remove(cls, configuration: HttpClientConfiguration):\n if configuration in cls._INSTANCES:\n del cls._INSTANCES[configuration]","def test_component_configuration_removed_from_agent_config(self):\n with cd(self._get_cwd()):\n self.run_cli_command(\n \"add\", \"--local\", self.ITEM_TYPE, str(self.ITEM_PUBLIC_ID)\n )\n self.run_cli_command(\"add\", \"--local\", \"connection\", \"fetchai/http_server\")\n\n self.runner.invoke(\n cli,\n [\n \"config\",\n \"set\",\n \"vendor.fetchai.connections.soef.config.api_key\",\n \"some_api_key\",\n ],\n standalone_mode=False,\n catch_exceptions=False,\n )\n self.runner.invoke(\n cli,\n [\n \"config\",\n \"set\",\n \"vendor.fetchai.connections.http_server.config.port\",\n \"9000\",\n ],\n standalone_mode=False,\n catch_exceptions=False,\n )\n config = self.load_config()\n assert config.component_configurations\n assert (\n PackageId(self.ITEM_TYPE, self.ITEM_PUBLIC_ID)\n in config.component_configurations\n )\n\n self.run_cli_command(\"remove\", self.ITEM_TYPE, str(self.ITEM_PUBLIC_ID))\n\n config = self.load_config()\n assert (\n PackageId(self.ITEM_TYPE, self.ITEM_PUBLIC_ID)\n not in config.component_configurations\n )\n assert config.component_configurations","def tearDown(self) -> None:\n os.remove(TestConfigFile.TEST_CONFIG)","def pre_config_root_delete(self, resource_id):\n pass","def delete_account_key(configuration):\n os.remove(configuration.cm_key)"],"string":"[\n \"def remove_local_config(self):\\n with ignored(OSError):\\n os.remove(os.path.join(self.rundir, const.LOCAL_CONFIG_FILE))\",\n \"def delete_container(self, container: Container):\",\n \"def delete_container(self, account, container):\\n \\n pass\",\n \"def delete_container(ContainerName=None):\\n pass\",\n \"async def before_cleanup(self, invoker: PluginInvoker):\\n config_file = invoker.files[\\\"config\\\"]\\n try:\\n config_file.unlink()\\n except FileNotFoundError:\\n pass\\n logging.debug(f\\\"Deleted configuration at {config_file}\\\")\",\n \"def kubeconfig_delete(self):\\n\\n self._client.delete(\\n \\\"{}/kubeconfig\\\".format(LKECluster.api_endpoint), model=self\\n )\",\n \"def clean():\\n Log.d(DEBUG_TAG, \\\"Delete config file...\\\")\\n try:\\n os.remove(CONFIG_FILE)\\n except os.error as e:\\n Log.e(DEBUG_TAG, \\\"Delete config file%s error, reason:%s\\\"%(CONFIG_FILE, e))\",\n \"def keystone_departed():\\n with charm.provide_charm_instance() as charm_instance:\\n charm_instance.remove_config()\",\n \"def delete(self):\\n try:\\n self._client.delete_launch_configuration(LaunchConfigurationName=self._name)\\n except botocore.exceptions.ClientError as e:\\n if \\\"not found\\\" in e.response[\\\"Error\\\"][\\\"Message\\\"]:\\n logger.warn(\\\"Launch configuration %s not found\\\", self._name)\\n else:\\n raise\",\n \"def remove_config(name):\\n db = dbm.open(config_file, 'c')\\n del db[name]\\n db.close()\",\n \"def do_DELETE(self): # pylint: disable=C0103\\r\\n if self.path == \\\"/del_config\\\" or self.path == \\\"/del_config/\\\":\\r\\n self.server.config = dict()\\r\\n self.log_message(\\\"Reset Server Configuration.\\\")\\r\\n self.send_response(200)\\r\\n else:\\r\\n self.send_response(404)\",\n \"def delete_configuration(self, node, ports):\\n return hpssa_manager.delete_configuration()\",\n \"def delete(configsetname):\\n cnfset = configsetPath(configsetname)\\n files = os.listdir(cnfset)\\n for f in files: os.remove(os.path.join(cnfset, f))\\n os.rmdir(cnfset)\\n return None\",\n \"def remove(cls, config: Dict) -> None:\\n node = get_node_by_id(cls.cluster, config[\\\"node\\\"])\\n id_ = config[\\\"id\\\"]\\n\\n cls.shell(\\n args=[\\\"ceph\\\", \\\"auth\\\", \\\"del\\\", id_],\\n )\\n\\n if config.get(\\\"remove_admin_keyring\\\"):\\n node.exec_command(\\n cmd=\\\"rm -rf /etc/ceph/ceph.client.admin.keyring\\\",\\n sudo=True,\\n )\\n\\n node.exec_command(\\n sudo=True, cmd=f\\\"rm -rf /etc/ceph/ceph.{id_}.keyring\\\", check_ec=False\\n )\\n\\n out, _ = node.exec_command(cmd=\\\"ls -ltrh /etc/ceph/\\\", sudo=True)\\n log.info(out)\\n\\n # Remove packages like ceph-common\\n # Be-careful it may remove entire /etc/ceph directory\\n if config.get(\\\"remove_packages\\\"):\\n for pkg in config.get(\\\"remove_packages\\\"):\\n node.exec_command(\\n cmd=f\\\"yum remove -y {pkg}\\\",\\n sudo=True,\\n )\",\n \"def delete(self):\\r\\n return self.connection.delete_launch_configuration(self.name)\",\n \"def delete_endpoint_config(EndpointConfigName=None):\\n pass\",\n \"def reset_server_configuration_fixture():\\n config_instance = Configuration()\\n Path(config_instance.server_config_dir, 'test-gigantum-com.json').unlink()\\n Path(config_instance.server_config_dir, 'CURRENT').unlink()\\n config_instance._get_redis_client().delete(config_instance.SERVER_CONFIG_CACHE_KEY,\\n config_instance.AUTH_CONFIG_CACHE_KEY)\\n Path(config_instance.server_data_dir, 'test-gigantum-com').rmdir()\",\n \"def _destroy(self):\\r\\n if self._client:\\r\\n self._client.returnNr(self._nr)\\r\\n self._client.unregisterContainer(self)\\r\\n self._client = None\\r\\n\\r\\n if self._confDir:\\r\\n shutil.rmtree(self._confDir, True)\\r\\n self._confDir = None\\r\\n\\r\\n if self._dataDir:\\r\\n shutil.rmtree(self._dataDir, True)\\r\\n self._dataDir = None\",\n \"def clean():\\n local('rm -fr %s' % os.path.abspath(env.config['destination']))\",\n \"def config_exit(self):\\n self._master.destroy()\\n self._config_status = False # ensure the world wouldn't be built\",\n \"def remove_stored_config(self):\\n stored_config_filename = self.stored_config_filename\\n if stored_config_filename.exists():\\n stored_config_filename.remove()\\n self._stored_cmake_generator = self._stored_config.cmake_generator\",\n \"def remove_config_object() -> None:\\n if G_CONFIG_OBJECT:\\n G_CONFIG_OBJECT.clear()\",\n \"def delete_conf(src_ip):\\n return delete_route(src_ip)\",\n \"def del_conf(self, path):\\n\\t\\tself.monitor.removePath(path)\\n\\t\\tself.cache.pop(path, None)\",\n \"def clear(self):\\r\\n del self.__config\\r\\n self.__config = {}\\r\\n self.save()\",\n \"def delete_k8s_configuration(client, resource_group_name, cluster_name, name, cluster_type):\\n # Determine ClusterRP\\n cluster_rp = __get_cluster_type(cluster_type)\\n\\n source_control_configuration_name = name\\n\\n return client.delete(resource_group_name, cluster_rp, cluster_type, cluster_name, source_control_configuration_name)\",\n \"def test_delete_namespaced_deployment_config(self):\\n pass\",\n \"def removeConfigFile(alg):\\r\\n configPath = alg.getParameterValue('config')\\r\\n if isWindows():\\r\\n command = \\\"DEL {}\\\".format(os.path.join(rliPath(), configPath))\\r\\n else:\\r\\n command = \\\"rm {}\\\".format(os.path.join(rliPath(), configPath))\\r\\n alg.commands.append(command)\",\n \"def cleanup(self):\\n self.qemu.clean_run_files()\\n for tmp in glob.glob(self.configfile + \\\"?*\\\"):\\n os.unlink(tmp)\",\n \"def DeleteConfig(self, request, context):\\n context.set_code(grpc.StatusCode.UNIMPLEMENTED)\\n context.set_details('Method not implemented!')\\n raise NotImplementedError('Method not implemented!')\",\n \"def reset(args):\\n if os.path.exists(args.config):\\n os.remove(args.config)\\n return\",\n \"def remove_user_configuration(self):\\n shutil.rmtree(self.test.user_conf_dir())\",\n \"def reset_config():\\r\\n # TODO implement configuration reset\\r\\n pass\",\n \"def do_delete_configured_volume(self, arg):\\n args = self.parse_arguments(arg)\\n if len(args) == 0:\\n self.perror(\\\"No storage specified.\\\")\\n return\\n self.do_coroutine(self._localStorageRoutines.delete_configured_volume_routine(args[0]))\",\n \"def docker_remove(self) -> int:\\n try:\\n container = self.client.containers.get(self.cname)\\n except docker.errors.NotFound:\\n return\\n\\n info(\\\"Removing container {}...\\\".format(self.cname), nl=False)\\n container.remove(force=True)\\n info(\\\"Done!\\\")\",\n \"def remove_trap_config(self, context, storage_id, trap_config):\\n # Currently not implemented\\n pass\",\n \"def del_cfgs (conn):\\n\\n try:\\n csr = conn.cursor()\\n\\n cmd = \\\"DELETE FROM {tbl};\\\".\\\\\\n format(tbl = _tbl_config)\\n print(cmd)\\n\\n csr.execute(cmd)\\n csr.close()\\n\\n except Exception as ex:\\n print(\\\"Error - del_cfgs: {0}\\\".format(ex))\\n rc_err = ex.args[0]\\n return rc_err\\n\\n return rc_ok\",\n \"async def websocket_lovelace_delete_config(\\n hass: HomeAssistant,\\n connection: websocket_api.ActiveConnection,\\n msg: dict[str, Any],\\n config: LovelaceStorage,\\n) -> None:\\n await config.async_delete()\",\n \"def deleted(self, configurationId):\\n log.debug('ConfigListener: configuration %s deleted' % configurationId)\\n ZenProcessTask.DEVICE_STATS.pop(configurationId, None)\",\n \"def delete_configs(configholder, configs):\\n for config_name in configs:\\n configholder.delete_config(config_name)\",\n \"def destroy(self):\\n logger.info(\\\"Removing container '%s'\\\", self.name)\\n if not self.container.destroy():\\n logger.warning(\\\"lxc-destroy failed, trying to remove directory\\\")\\n # We check that LXCBASE/NAME/config exists because if it does then\\n # lxc destroy should have succeeded and the failure is elsewhere,\\n # for example the container is still running\\n if os.path.isdir(self.containerpath) \\\\\\n and self.containerpath.startswith(const.LXCBASE) \\\\\\n and not os.path.exists(\\n os.path.join(self.containerpath, \\\"config\\\")):\\n shutil.rmtree(self.containerpath)\\n else:\\n raise ContainerError(\\\"Path doesn't exist: {}\\\".format(self.containerpath))\\n logger.debug(\\\"Done\\\")\",\n \"def rm_network(c):\\n print('Stopping local test network and removing containers')\\n with c.cd('images'):\\n c.run('sudo docker-compose down -v', hide='stderr')\\n\\n c.run('sudo rm -rf volumes/stellar-core/opt/stellar-core/buckets')\\n c.run('sudo rm -f volumes/stellar-core/opt/stellar-core/*.log')\\n c.run('sudo rm -rf volumes/stellar-core/tmp')\",\n \"def rpc_delete_config(self, unused_session, rpc, *unused_params):\\n raise ncerror.OperationNotSupportedProtoError(rpc)\",\n \"def clear_config():\\n check_config()\\n fs.truncate(PYWS_DIR_BIN)\",\n \"def test_destroy_container(self):\\n pass\",\n \"def delete_handler(event, context):\\n delete_endpoint_config(event)\",\n \"def test_delete_config_root(self):\\n config_root = self._create_config_root()\\n config_root_uuid = config_root['config-root']['uuid']\\n with self.override_role():\\n self.config_client.delete_config_root(\\n config_root_uuid)\",\n \"def cli(ctx):\\n stopped = click.style(\\\"Stopped\\\", fg=\\\"red\\\")\\n removed = click.style(\\\"Removed\\\", fg=\\\"blue\\\")\\n for container in ctx.docker.get_containers():\\n name = container.hostname\\n node_name = ''.join([i for i in name if not i.isdigit()])\\n image_name = container.dictionary['Config']['Image']\\n if node_name in TO_KILL:\\n container.stop(timeout=0)\\n else:\\n container.stop(timeout=5)\\n # container.execute(\\\"poweroff\\\", \\\"root\\\", \\\"/\\\", False)\\n # container.wait()\\n ctx.log(\\\"Container %s --> %s\\\" % (name, stopped))\\n container.remove(v=False, link=False, force=True)\\n ctx.log(\\\"Container %s --> %s\\\" % (name, removed))\\n ctx.state['containers'].remove(container.short_id)\\n ctx.state.fast_dump()\\n # remove untagged image\\n if not image_name.startswith(ctx.prefix):\\n ctx.docker.remove_image(image_name, force=True)\\n ctx.docker.remove_network()\",\n \"def delete_directory_config(DirectoryName=None):\\n pass\",\n \"async def DeleteRoutine(self, name: str):\\n #okay. problem was being cased by this line.\\n #the problem is, that we delete items as part of updating\\n #from gitlab. And in that case, we don't want to wipe out the local config.\\n #so while it may seem like we should conveniently do this, probably, we should not.\\n\\n #await self.delete_local_configuration_routine(name)\",\n \"def test_config_remove(self):\\n server = self.start_server(\\\"hello world\\\", 200)\\n try:\\n self.setup_dynamic()\\n\\n cfg_file = \\\"test.yml\\\"\\n\\n self.write_dyn_config(\\n cfg_file, self.http_cfg(\\\"myid\\\", \\\"http://localhost:{}\\\".format(server.server_port)))\\n\\n self.wait_until(lambda: self.output_has(lines=2))\\n\\n self.assert_last_status(\\\"up\\\")\\n\\n os.remove(self.monitors_dir() + cfg_file)\\n\\n # Ensure the job was removed from the schduler\\n self.wait_until(lambda: self.log_contains(\\\"Remove scheduler job 'myid'\\\"))\\n self.wait_until(lambda: self.log_contains(\\\"Job 'myid' returned\\\"))\\n\\n self.proc.check_kill_and_wait()\\n finally:\\n server.shutdown()\",\n \"def remove(ctx, name, project_root):\\n\\n if name == 'logme':\\n raise LogmeError(\\\"'logme' master logger configuration cannot be removed!\\\")\\n\\n with ensure_conf_exist(project_root) as logme_conf:\\n\\n config = read_config(logme_conf)\\n config.remove_section(name)\\n\\n with logme_conf.open('w+') as conf:\\n config.write(conf)\",\n \"def delete_config_callback(self, trigger_id, config):\\n self.tcex.log.trace('delete config callback')\",\n \"def remove(self, container):\\n pass\",\n \"def delete_uptime_check_config(config_name: str) -> None:\\n client = monitoring_v3.UptimeCheckServiceClient()\\n client.delete_uptime_check_config(request={\\\"name\\\": config_name})\\n print(\\\"Deleted \\\", config_name)\",\n \"def purge_config_cache(location=None):\\n\\n cache_path = get_cache_path(location)\\n\\n if location:\\n os.remove(cache_path)\\n else:\\n shutil.rmtree(cache_path)\",\n \"def container_delete(ctx, token, container_ids, force):\\n try:\\n out = ctx.obj.container_delete(token, container_ids, force)\\n print_message(out)\\n except exceptions.DockerException as e:\\n m = e.message\\n print_error(m)\",\n \"def test_del_empty_config():\\n\\n testutils.deploy_config_raw(\\\"\\\")\\n\\n assert prop.del_prop('info', 'sdk') != 0\\n\\n testutils.undeploy()\\n\\n return 0\",\n \"def delete_notebook_instance_lifecycle_config(NotebookInstanceLifecycleConfigName=None):\\n pass\",\n \"def remove_pgsql_conf(self):\\n self.kv.unset(\\\"pgsql_host\\\")\\n self.kv.unset(\\\"pgsql_port\\\")\\n self.kv.unset(\\\"pgsql_db\\\")\\n self.kv.unset(\\\"pgsql_user\\\")\\n self.kv.unset(\\\"pgsql_pass\\\")\\n self.kv.flush()\",\n \"def delete_config_set(self, req, id):\\n try:\\n deleted_config_set = self.db_api.config_set_destroy(\\n req.context, id)\\n msg = _LI(\\\"Successfully deleted config_set %(id)s\\\") % {'id': id}\\n LOG.info(msg)\\n return dict(config_set=deleted_config_set)\\n except exception.ForbiddenPublicImage:\\n msg = _LI(\\\"Delete denied for public config_set %(id)s\\\") % {\\n 'id': id}\\n LOG.info(msg)\\n raise exc.HTTPForbidden()\\n except exception.Forbidden as e:\\n # If it's private and doesn't belong to them, don't let on\\n # that it exists\\n LOG.info(e)\\n return exc.HTTPForbidden(e)\\n except exception.NotFound:\\n msg = _LI(\\\"config_set %(id)s not found\\\") % {'id': id}\\n LOG.info(msg)\\n return exc.HTTPNotFound()\\n except Exception:\\n LOG.exception(_LE(\\\"Unable to delete config_set %s\\\") % id)\\n raise\",\n \"def test_delete_global_system_config(self):\\n new_config = self._create_global_system_config()\\n with self.override_role():\\n self.config_client.delete_global_system_config(new_config['uuid'])\",\n \"def delete(self, configuration):\\n configuration = g.user.get_api().get_configuration(configuration)\\n configuration.delete()\\n return '', 204\",\n \"async def clear_config(self, ctx, guild_id: int):\\n try:\\n result = await db.Config.filter(guild_id=guild_id).delete()\\n except Exception as e:\\n result = f\\\"{e.__class__.__name__}: {e}\\\"\\n db.config_cache.pop(guild_id)\\n await ctx.send(f\\\"```py\\\\n{result}\\\\n```\\\")\",\n \"def test_delete_namespaced_build_config(self):\\n pass\",\n \"def remove_config(self, config):\\n for fn in config:\\n try:\\n os.remove(fn)\\n LOGGER.debug('Removed backup: %s', fn)\\n\\n except IOError as e:\\n if e.errno != errno.ENOENT:\\n LOGGER.warning('Could not remove backup: %s', fn)\",\n \"def remove_docker_compose_file():\\n os.remove(DOCKER_COMPOSE_FILE)\",\n \"def remove_prompt(name, delete_config):\\n\\n with open(DATABASE_FILE_PATH) as f:\\n config = json.load(f)\\n path = config[name]\\n del config[name]\\n\\n with open(DATABASE_FILE_PATH, 'w') as f:\\n json.dump(config, f)\\n\\n if delete_config:\\n os.remove(path)\",\n \"def destroy_lxd_container(container):\\n\\n if type(container) is bool:\\n return\\n\\n name = container.name\\n debug(\\\"Destroying container {}\\\".format(name))\\n\\n client = get_lxd_client()\\n\\n def wait_for_stop(timeout=30):\\n \\\"\\\"\\\"Wait for eth0 to have an ipv4 address.\\\"\\\"\\\"\\n starttime = time.time()\\n while(time.time() < starttime + timeout):\\n time.sleep(1)\\n if container.state == \\\"Stopped\\\":\\n return\\n\\n def wait_for_delete(timeout=30):\\n starttime = time.time()\\n while(time.time() < starttime + timeout):\\n time.sleep(1)\\n if client.containers.exists(name) is False:\\n return\\n\\n try:\\n container.stop(wait=False)\\n wait_for_stop()\\n except Exception as ex:\\n debug(\\n \\\"Error stopping container {}: {}\\\".format(\\n name,\\n ex,\\n )\\n )\\n\\n try:\\n container.delete(wait=False)\\n wait_for_delete()\\n except Exception as ex:\\n debug(\\n \\\"Error deleting container {}: {}\\\".format(\\n name,\\n ex,\\n )\\n )\\n\\n try:\\n # Delete the profile created for this container\\n profile = client.profiles.get(name)\\n if profile:\\n profile.delete()\\n except Exception as ex:\\n debug(\\n \\\"Error deleting profile {}: {}\\\".format(\\n name,\\n ex,\\n )\\n )\",\n \"def unconfigure_set(cluster, cursor, name, configuration):\\n logger.info('Unconfiguring replication set on %s...', cursor.connection.dsn)\\n\\n # Drop the transaction queue if it exists.\\n logger.info('Dropping transaction queue...')\\n cursor.execute(\\\"SELECT pgq.drop_queue(%s)\\\", (cluster.get_queue_name(name),))\\n\\n for table in configuration.tables:\\n drop_trigger(cluster, cursor, name, table.schema, table.name)\",\n \"def tearDown(self):\\n test_utils.delete_test_config()\",\n \"def delete(ctx, **_):\\n # Delete the resource\\n azure_config = ctx.node.properties.get('azure_config')\\n if not azure_config.get(\\\"subscription_id\\\"):\\n azure_config = ctx.node.properties.get('client_config')\\n else:\\n ctx.logger.warn(\\\"azure_config is deprecated please use client_config, \\\"\\n \\\"in later version it will be removed\\\")\\n resource_group_name = utils.get_resource_group(ctx)\\n vm_name = ctx.instance.runtime_properties.get('virtual_machine')\\n name = ctx.instance.runtime_properties.get('name')\\n api_version = \\\\\\n ctx.node.properties.get('api_version', constants.API_VER_COMPUTE)\\n vm_extension = VirtualMachineExtension(azure_config, ctx.logger,\\n api_version)\\n utils.handle_delete(ctx, vm_extension, resource_group_name, name, vm_name)\",\n \"def remove_venv_config(name: str) -> Path:\\n config_file_path = find_vsh_config(name=name, check=False)\\n if config_file_path.exists():\\n config_file_path.unlink()\\n return config_file_path\",\n \"def clear(self):\\n with open(self.config_file, mode='w') as f:\\n data = {}\\n d = json.dumps(data)\\n f.write(d)\",\n \"def DeleteContainers(self):\\n for container in itertools.chain(*list(self.containers.values())):\\n container.Delete()\",\n \"def cleanup(self):\\n self.exit_config_mode()\",\n \"def delete(name, config, backend, storage, debug):\\n setup_lithops_logger(logging.DEBUG)\\n\\n verify_runtime_name(name)\\n\\n if config:\\n config = load_yaml_config(config)\\n\\n setup_lithops_logger(logging.DEBUG)\\n\\n config_ow = set_config_ow(backend, storage, runtime_name=name)\\n config = default_config(config, config_ow)\\n\\n if config['lithops']['mode'] != SERVERLESS:\\n raise Exception('\\\"lithops runtime delete\\\" command is only valid for serverless backends')\\n\\n storage_config = extract_storage_config(config)\\n internal_storage = InternalStorage(storage_config)\\n compute_config = extract_serverless_config(config)\\n compute_handler = ServerlessHandler(compute_config, internal_storage)\\n\\n runtimes = compute_handler.list_runtimes(name)\\n for runtime in runtimes:\\n compute_handler.delete_runtime(runtime[0], runtime[1])\\n runtime_key = compute_handler.get_runtime_key(runtime[0], runtime[1])\\n internal_storage.delete_runtime_meta(runtime_key)\",\n \"def test_delete_collection_namespaced_deployment_config(self):\\n pass\",\n \"def pytest_unconfigure(config):\\n db = Graph(DEFAULT_DB)\\n db.delete_all()\",\n \"def rm(ws):\\n ws.docker_remove()\",\n \"def delete_host(self, conf, tenant_id, network_id, host_id):\\n\\t\\tpass\",\n \"def remove(self, host):\\n for p, c in self.configs_:\\n if host in c.hosts_:\\n c.remove(host)\\n return\\n raise ValueError(\\\"Host %s: not found\\\" % host)\",\n \"def clean_azml_workspace(ctx):\\n\\n ws = get_workspace(config)\\n\\n # remove compute clusters\\n for _, compute in ws.compute_targets.items():\\n if not compute.provisioning_state == \\\"Deleting\\\":\\n print(f\\\"Deleting {compute.name}\\\")\\n compute.delete()\",\n \"def delete_configuration(ctx, name: Optional[str], assume_yes: bool):\\n config_set = __ensure_configuration_exists(ctx)\\n\\n config = __ensure_name_in_config_set(ctx, name, config_set)\\n\\n # Confirm for override\\n if not assume_yes:\\n click.confirm(\\n 'The configuration \\\"{}\\\" will be removed. Do you want to continue?'.format(config.printable_name),\\n abort=True)\\n\\n c = config_set[name]\\n config_set.remove(name)\\n\\n if len(config_set) == 0:\\n # There are no configurations\\n os.unlink(abejacli.configuration.CONFIG_FILE_PATH)\\n return\\n\\n # Change active configuration\\n if name == config_set.active_config_name:\\n if name is None:\\n # default configuration removed. choose the first one.\\n config_set.active_config_name = next(iter(config_set)).name\\n __save_config_set(config_set)\\n else:\\n if None in config_set:\\n config_set.active_config_name = None\\n else:\\n config_set.active_config_name = next(iter(config_set)).name\\n\\n __save_config_set(config_set)\\n\\n click.echo('[INFO]: The configuration \\\"{}\\\" successfully deleted.'.format(\\n c.printable_name))\",\n \"def pre_global_vrouter_config_delete(self, resource_id):\\n pass\",\n \"def deconfigure(self):\\n\\n pass\",\n \"def clean_cluster_config(self, clusterid, config, **kwargs):\\n pass\",\n \"def clean_config(job_cfg_path, fixtures_path):\\n tree = ET.parse(job_cfg_path)\\n root = tree.getroot()\\n inject_tree = ET.parse(fixtures_path)\\n for node in inject_tree.getroot():\\n srcnode = root.find(\\\"./%s\\\" % node.tag)\\n if srcnode is not None:\\n root.remove(srcnode)\\n tree.write(job_cfg_path)\",\n \"def deconfigure(self):\\n\\n self.platform.deconfigure()\",\n \"def test_delete_hyperflex_vcenter_config_policy(self):\\n pass\",\n \"def pre_global_system_config_delete(self, resource_id):\\n pass\",\n \"def clean_docker(c):\\n c.run(f'docker image rm -f $(docker image ls --filter reference={docker_repo} -q) || true')\",\n \"def cleanup_infrastructure_storage(config, datacenter):\\n print \\\"Removing storage devices in datacenter %s...\\\" % datacenter.getName()\\n for device in datacenter.listStorageDevices():\\n device.delete()\",\n \"def test_delete_config_node(self):\\n config_node = self._create_config_node()\\n config_node_uuid = config_node['config-node']['uuid']\\n with self.override_role():\\n self.config_client.delete_config_node(\\n config_node_uuid)\",\n \"def docker_rm(args, container_id): # type: (EnvironmentConfig, str) -> None\\n try:\\n docker_command(args, ['rm', '-f', container_id], capture=True)\\n except SubprocessError as ex:\\n if 'no such container' in ex.stderr:\\n pass # podman does not handle this gracefully, exits 1\\n else:\\n raise ex\",\n \"def remove(cls, configuration: HttpClientConfiguration):\\n if configuration in cls._INSTANCES:\\n del cls._INSTANCES[configuration]\",\n \"def test_component_configuration_removed_from_agent_config(self):\\n with cd(self._get_cwd()):\\n self.run_cli_command(\\n \\\"add\\\", \\\"--local\\\", self.ITEM_TYPE, str(self.ITEM_PUBLIC_ID)\\n )\\n self.run_cli_command(\\\"add\\\", \\\"--local\\\", \\\"connection\\\", \\\"fetchai/http_server\\\")\\n\\n self.runner.invoke(\\n cli,\\n [\\n \\\"config\\\",\\n \\\"set\\\",\\n \\\"vendor.fetchai.connections.soef.config.api_key\\\",\\n \\\"some_api_key\\\",\\n ],\\n standalone_mode=False,\\n catch_exceptions=False,\\n )\\n self.runner.invoke(\\n cli,\\n [\\n \\\"config\\\",\\n \\\"set\\\",\\n \\\"vendor.fetchai.connections.http_server.config.port\\\",\\n \\\"9000\\\",\\n ],\\n standalone_mode=False,\\n catch_exceptions=False,\\n )\\n config = self.load_config()\\n assert config.component_configurations\\n assert (\\n PackageId(self.ITEM_TYPE, self.ITEM_PUBLIC_ID)\\n in config.component_configurations\\n )\\n\\n self.run_cli_command(\\\"remove\\\", self.ITEM_TYPE, str(self.ITEM_PUBLIC_ID))\\n\\n config = self.load_config()\\n assert (\\n PackageId(self.ITEM_TYPE, self.ITEM_PUBLIC_ID)\\n not in config.component_configurations\\n )\\n assert config.component_configurations\",\n \"def tearDown(self) -> None:\\n os.remove(TestConfigFile.TEST_CONFIG)\",\n \"def pre_config_root_delete(self, resource_id):\\n pass\",\n \"def delete_account_key(configuration):\\n os.remove(configuration.cm_key)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.68364567","0.65952647","0.65655595","0.63887167","0.6293753","0.6252849","0.6222041","0.6218625","0.6210771","0.61385065","0.6115384","0.6097698","0.60793775","0.60496986","0.6009285","0.6003192","0.59821314","0.59776366","0.5943736","0.5928523","0.5888046","0.5878867","0.5877662","0.587197","0.58602136","0.58570594","0.5850817","0.5849261","0.58488315","0.5808771","0.58063775","0.58008575","0.5792463","0.5788962","0.5785662","0.5784606","0.57830566","0.57805556","0.57767373","0.57590663","0.57581145","0.5746081","0.57343394","0.5721346","0.5720577","0.5706954","0.5705855","0.5688071","0.5686725","0.56710714","0.5670638","0.5669616","0.5648786","0.5644828","0.56184274","0.560975","0.5604498","0.56019944","0.5601587","0.5565885","0.5565474","0.55390286","0.55262244","0.5521072","0.5517812","0.55086225","0.5490924","0.5490858","0.5488788","0.5486716","0.54833853","0.54680014","0.5467445","0.5459203","0.5451184","0.54421216","0.543876","0.5435975","0.54280686","0.5423495","0.5413689","0.54094005","0.53979725","0.5397049","0.53958184","0.5395618","0.53927314","0.53865373","0.53771305","0.537674","0.53758657","0.5375098","0.53687793","0.5366386","0.53648067","0.53613305","0.5352578","0.53498137","0.53490984","0.53399384"],"string":"[\n \"0.68364567\",\n \"0.65952647\",\n \"0.65655595\",\n \"0.63887167\",\n \"0.6293753\",\n \"0.6252849\",\n \"0.6222041\",\n \"0.6218625\",\n \"0.6210771\",\n \"0.61385065\",\n \"0.6115384\",\n \"0.6097698\",\n \"0.60793775\",\n \"0.60496986\",\n \"0.6009285\",\n \"0.6003192\",\n \"0.59821314\",\n \"0.59776366\",\n \"0.5943736\",\n \"0.5928523\",\n \"0.5888046\",\n \"0.5878867\",\n \"0.5877662\",\n \"0.587197\",\n \"0.58602136\",\n \"0.58570594\",\n \"0.5850817\",\n \"0.5849261\",\n \"0.58488315\",\n \"0.5808771\",\n \"0.58063775\",\n \"0.58008575\",\n \"0.5792463\",\n \"0.5788962\",\n \"0.5785662\",\n \"0.5784606\",\n \"0.57830566\",\n \"0.57805556\",\n \"0.57767373\",\n \"0.57590663\",\n \"0.57581145\",\n \"0.5746081\",\n \"0.57343394\",\n \"0.5721346\",\n \"0.5720577\",\n \"0.5706954\",\n \"0.5705855\",\n \"0.5688071\",\n \"0.5686725\",\n \"0.56710714\",\n \"0.5670638\",\n \"0.5669616\",\n \"0.5648786\",\n \"0.5644828\",\n \"0.56184274\",\n \"0.560975\",\n \"0.5604498\",\n \"0.56019944\",\n \"0.5601587\",\n \"0.5565885\",\n \"0.5565474\",\n \"0.55390286\",\n \"0.55262244\",\n \"0.5521072\",\n \"0.5517812\",\n \"0.55086225\",\n \"0.5490924\",\n \"0.5490858\",\n \"0.5488788\",\n \"0.5486716\",\n \"0.54833853\",\n \"0.54680014\",\n \"0.5467445\",\n \"0.5459203\",\n \"0.5451184\",\n \"0.54421216\",\n \"0.543876\",\n \"0.5435975\",\n \"0.54280686\",\n \"0.5423495\",\n \"0.5413689\",\n \"0.54094005\",\n \"0.53979725\",\n \"0.5397049\",\n \"0.53958184\",\n \"0.5395618\",\n \"0.53927314\",\n \"0.53865373\",\n \"0.53771305\",\n \"0.537674\",\n \"0.53758657\",\n \"0.5375098\",\n \"0.53687793\",\n \"0.5366386\",\n \"0.53648067\",\n \"0.53613305\",\n \"0.5352578\",\n \"0.53498137\",\n \"0.53490984\",\n \"0.53399384\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7014883"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":20194,"cells":{"query":{"kind":"string","value":"Create a new container and put it in the local registry."},"document":{"kind":"string","value":"async def CreateUpdateRoutine(self, name: str):\n raise NotImplementedError()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def container(name, ostemplate, **kwargs):\n if not openvz.exists(name):\n ctid = openvz.get_available_ctid()\n openvz.create(ctid, ostemplate=ostemplate, **kwargs)\n openvz.set(ctid, name=name)\n return Container(name)","def _create_container(self, container_name):\n try:\n container = self.swift.head_container(container_name)\n except client.ClientException:\n self.swift.put_container(container_name)\n else:\n return container","def test_create_container(self):\n pass","def create_container(ContainerName=None, Tags=None):\n pass","def create_container(self, container_name):\n response = self.client.put_container(container_name)\n return response","def _start_instance(self, resource_handler):\n log.debug('Starting container')\n cli = resource_handler.cli\n #host_config=cli.create_host_config(network_mode=self.network_mode)\n container = cli.create_container(\n image='{0.image}:{0.tag}'.format(self),\n command=self.command,\n #host_config=host_config,\n environment=self.env\n )\n\n cli.start(container.get('Id'))\n log.debug('Started container [%s]', container)\n return str(container)","async def CreateContainer(self, *args):\n # Create and configure a LXD container for use with a proxy charm.\n (model, application, _, _) = args\n\n debug(\"[CreateContainer] {}\".format(args))\n container = None\n\n try:\n # Execute 'get-ssh-public-key' primitive and get returned value\n uuid = await self.n2vc.ExecutePrimitive(\n model,\n application,\n \"get-ssh-public-key\",\n None,\n )\n\n result = await self.n2vc.GetPrimitiveOutput(model, uuid)\n pubkey = result['pubkey']\n\n container = create_lxd_container(\n public_key=pubkey,\n name=os.path.basename(__file__)\n )\n\n return container\n except Exception as ex:\n debug(\"Error creating container: {}\".format(ex))\n pass\n\n return None","def _create_docker_container(self):\n cwd = os.getcwd()\n\n # get a docker client\n docker_client = docker.from_env()\n docker_image = \"aca_build0:latest\"\n mount_pnt = docker.types.Mount(\"/mnt/alcor-control-agent\",\n f'''{cwd}/../..''',\n type='bind')\n\n mount_modules = docker.types.Mount(\"/lib/modules\",\n \"/lib/modules\",\n type='bind')\n\n # Create the container in privileged mode\n container = docker_client.containers.create(\n docker_image, '/bin/bash', tty=True,\n stdin_open=True, auto_remove=False, mounts=[mount_pnt, mount_modules],\n privileged=True, cap_add=[\"SYS_PTRACE\"],\n ports={str(aca_droplet.port_internal) + \"/tcp\": ('0.0.0.0', aca_droplet.port_external)},\n security_opt=[\"seccomp=unconfined\"], name=self.id)\n container.start()\n container.reload()\n\n # Increment the static external port number counter\n aca_droplet.port_external = aca_droplet.port_external + 1\n\n # Restart dependancy services\n container.exec_run(\"/etc/init.d/rpcbind restart\")\n container.exec_run(\"/etc/init.d/rsyslog restart\")\n container.exec_run(\"ip link set dev eth0 up mtu 9000\")\n\n # We may need to restart ovs\n # container.exec_run(\"/etc/init.d/openvswitch-switch restart\")\n\n # Create simlinks\n container.exec_run(\"ln -s /mnt/alcor-control-agent/mizar/build/bin /trn_bin\")\n container.exec_run(\"ln -s /mnt/alcor-control-agent/mizar/build/xdp /trn_xdp\")\n container.exec_run(\"ln -s /sys/fs/bpf /bpffs\")\n\n container.exec_run(\n \"ln -s /mnt/alcor-control-agent/build/ /aca_build\")\n\n # Run the transitd in the background\n container.exec_run(\"/trn_bin/transitd \",\n detach=True)\n\n # Enable debug and tracing for the kernel\n container.exec_run(\n \"mount -t debugfs debugfs /sys/kernel/debug\")\n container.exec_run(\n \"echo 1 > /sys/kernel/debug/tracing/tracing_on\")\n\n # Enable core dumps (just in case!!)\n container.exec_run(\"ulimit -u\")\n cmd = \"echo '/mnt/alcor-control-agent/mizar/core/core_{}_%e.%p' |\\\n tee /proc/sys/kernel/core_pattern \".format(self.ip)\n container.exec_run(cmd)\n\n self.container = container\n self.ip = self.container.attrs['NetworkSettings']['IPAddress']\n self.mac = self.container.attrs['NetworkSettings']['MacAddress']","def container_factory(self, name):","def container_factory(self, name):","def container_factory(self, name):","def container_factory(self, name):","def container_factory(self, name):","def register_this_container(cache, db):\n\n # Get container id.\n # bash_command = \"\"\"head -1 /proc/self/cgroup|cut -d/ -f3\"\"\"\n # output = str(subprocess.check_output(['bash','-c', bash_command]), \"utf-8\").strip()\n\n # logger.info(output)\n\n my_host_name = socket.gethostname()\n my_ip = socket.gethostbyname(my_host_name)\n cache[\"ip\"] = my_ip\n cache[\"host\"] = my_host_name\n\n free_cpu, free_mem = get_resources()\n\n logger.info({\"host_name\": my_host_name, \"ip\": my_ip})\n try:\n pipe = db.pipeline()\n pipe.sadd(SET_NAME, my_ip).hset(my_ip, mapping={\"host_id\": my_host_name, \"cpu\": free_cpu, \"mem\": free_mem})\n pipe.execute()\n except Exception as e:\n logger.error(e)\n raise e","def createContainer(self, uid, userID, data):\r\n container = self._createContainer(data, userID)\r\n self._getMachine(container).assignContainer(container, uid)\r\n return container","def create(dockerfile):\n\n path = os.path.dirname(dockerfile)\n\n container_name = input('Enter container name: ')\n port = input('Enter port number to map TCP port 5000 in the container, to a port on the Docker host: ')\n\n try:\n image = CLIENT.images.build(path=path, dockerfile=dockerfile, tag=\"my_app_image\")\n # Run a container and map TCP port 5000 in the container to a given port on the Docker host.\n container = CLIENT.containers.run('my_app_image', detach=True, ports={'5000/tcp': port},\n name=container_name)\n click.secho(\"Container created with name: {}. App is running \"\n \"on http://0.0.0.0:{}/ on the host.\"\n .format(container_name, port), bg='blue', fg='white')\n except (docker.errors.APIError, TypeError, OSError) as err:\n print(err)","def post(self, run=False, **container_dict):\n context = pecan.request.context\n compute_api = pecan.request.compute_api\n policy.enforce(context, \"container:create\",\n action=\"container:create\")\n\n try:\n run = strutils.bool_from_string(run, strict=True)\n except ValueError:\n msg = _('Valid run values are true, false, 0, 1, yes and no')\n raise exception.InvalidValue(msg)\n try:\n container_dict['tty'] = strutils.bool_from_string(\n container_dict.get('tty', False), strict=True)\n container_dict['stdin_open'] = strutils.bool_from_string(\n container_dict.get('stdin_open', False), strict=True)\n except ValueError:\n msg = _('Valid tty and stdin_open values are ''true'', '\n '\"false\", True, False, \"True\" and \"False\"')\n raise exception.InvalidValue(msg)\n\n # NOTE(mkrai): Intent here is to check the existence of image\n # before proceeding to create container. If image is not found,\n # container create will fail with 400 status.\n images = compute_api.image_search(context, container_dict['image'],\n True)\n if not images:\n raise exception.ImageNotFound(container_dict['image'])\n container_dict['project_id'] = context.project_id\n container_dict['user_id'] = context.user_id\n name = container_dict.get('name') or \\\n self._generate_name_for_container()\n container_dict['name'] = name\n if container_dict.get('memory'):\n container_dict['memory'] = \\\n str(container_dict['memory']) + 'M'\n if container_dict.get('restart_policy'):\n self._check_for_restart_policy(container_dict)\n container_dict['status'] = fields.ContainerStatus.CREATING\n new_container = objects.Container(context, **container_dict)\n new_container.create(context)\n\n if run:\n compute_api.container_run(context, new_container)\n else:\n compute_api.container_create(context, new_container)\n # Set the HTTP Location Header\n pecan.response.location = link.build_url('containers',\n new_container.uuid)\n pecan.response.status = 202\n return view.format_container(pecan.request.host_url, new_container)","def DeployContainer(self, base_name, container_spec):\n name = base_name + str(len(self.containers[base_name]))\n container = KubernetesContainer(container_spec=container_spec, name=name)\n self.containers[base_name].append(container)\n container.Create()","def put_container(self, account, container):\n \n pass","def createContainer(self, userID, data):\r\n while 1:\r\n uid = uuid4().hex\r\n\r\n if uid not in self._pendingContainer:\r\n break\r\n\r\n try:\r\n container = self._balancer.createContainer(uid, userID, data)\r\n except ContainerProcessError:\r\n # TODO: What should we do here?\r\n raise InternalError('Container can not be created.')\r\n\r\n endpoint = EnvironmentEndpoint(self._network, container)\r\n self._pendingContainer[uid] = endpoint\r\n return endpoint.createNamespace(), container","def test_add_container(self):\n with DockerHost('host', dind=False) as host:\n # Create a container with --net=none, add a calico interface to\n # it then check felix programs a route.\n node = host.create_workload(\"node\", network=NET_NONE)\n host.calicoctl(\"container add %s 192.168.1.1\" % node)\n\n # Create the profile, get the endpoint IDs for the containers and\n # add the profile to the endpoint so felix will pick it up.\n host.calicoctl(\"profile add TEST_GROUP\")\n ep = host.calicoctl(\"container %s endpoint-id show\" % node)\n host.calicoctl(\"endpoint %s profile set TEST_GROUP\" % ep)\n\n # Wait for felix to program down the route.\n check_route = partial(host.execute,\n \"ip route | grep '192\\.168\\.1\\.1'\")\n retry_until_success(check_route, ex_class=CalledProcessError)","def ddtest_create_generic_container_w_name(self, name=None):\n container_resp = self.behaviors.create_container(name, 'generic', [])\n self._check_container_create_response(container_resp)\n\n get_resp = self.container_client.get_container(container_resp.ref)\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\n name=name, type='generic')","def build_container(client):\n client.images.build(path=os.path.join(os.path.abspath(\"\"), \"docker\"), tag=\"scrape_light\")","def create(self):\n print('Creating container: {}'.format(self.cfg['name']))\n create = self.docker_client.create(**self.env)\n return create['id']","def remote_createContainer(self, uid, data):\r\n try:\r\n nr = self._nrs.pop()\r\n except KeyError:\r\n raise MaxNumberExceeded('Can not manage any additional container.')\r\n\r\n container = RCEContainer(self, nr, uid, data)\r\n return container.start().addCallback(lambda _: container)","def view_createContainer(self, user, tag, data={}):\r\n try:\r\n validateName(tag)\r\n except IllegalName as e:\r\n raise InvalidRequest('Container tag is invalid: {0}'.format(e))\r\n\r\n if tag in user.containers or tag in user.robots:\r\n raise InvalidRequest('Tag is already used for a container '\r\n 'or robot.')\r\n\r\n namespace, remote_container = user.realm.createContainer(user.userID,\r\n data)\r\n container = Container(namespace, remote_container)\r\n user.containers[tag] = container\r\n container.notifyOnDeath(user.containerDied)\r\n\r\n m = 'Container {0} successfully created.'.format(tag)\r\n d = DeferredList([namespace(), remote_container()],\r\n fireOnOneErrback=True, consumeErrors=True)\r\n return d.addCallback(lambda _: m)","def DeployContainer(self, name, container_spec):\n raise NotImplementedError()","def create(self, imagepath, upgrade=False, local_config=None):\n logger.info(\"Creating container '%s'\", self.name)\n\n if not os.path.exists(imagepath):\n raise ContainerError(\"'{}' doesn't exist. Please specify a valid image path.\".format(imagepath))\n\n # create base path a hardlink the iso\n os.makedirs(self.containerpath)\n container_imagepath = os.path.join(self.containerpath, os.path.basename(imagepath))\n try:\n os.link(imagepath, container_imagepath)\n except OSError:\n # might be on a different partition, fall back to symlink then\n os.symlink(imagepath, container_imagepath)\n\n self._mountiso(container_imagepath)\n\n if local_config:\n self.setup_local_config(local_config)\n\n # Base rootfs\n os.makedirs(os.path.join(self.containerpath, \"rootfs\"))\n # Tools\n os.makedirs(os.path.join(self.containerpath, \"tools\"))\n # tools and default config from otto\n self._copy_otto_files()\n\n self.container.load_config()\n\n if upgrade:\n self.upgrade()\n\n logger.debug(\"Creation done\")","def registry(self):\n if self._registry is None:\n print('Creating container registry...')\n registry_ops = self.registry_client.registries\n try:\n registry = registry_ops.get(\n self.resources.group.name,\n self.name,\n )\n except CloudError:\n registry_creation = registry_ops.create(\n self.resources.group.name,\n self.name,\n RegistryCreateParameters(\n location=self.storage.account.location,\n sku=ContainerRegistrySku(ContainerRegistrySkuName.basic),\n admin_user_enabled=True,\n storage_account=StorageAccountParameters(\n self.storage.account.name,\n self.storage.key,\n ),\n )\n )\n registry = registry_creation.result()\n self._registry = registry\n print('Got container registry:', registry.name)\n return self._registry","def test_create(set_env, container: Container):\n # pylint: disable=unused-argument\n assert container\n assert isinstance(container, Container)","def _newcontainer(self, siginfo):\n pass","def put_container(self, container):\n if self.onest.create_bucket(container):\n LOG.debug('put_container, create success. '\n 'Container: %s.', container)\n else:\n # If return false, means exist\n LOG.info(_LI('put_container, '\n 'container(%s) exist, just use it.'), container)","def ensure_container():\n return exec_fn(_init_container)","def run_container(self,\n name: str,\n command: Optional[str] = None,\n env: Optional[StrDict] = None,\n volumes: Optional[Dict[str, StrDict]] = None,\n ports: Optional[Dict[Any, Any]] = None,\n dns: Optional[List[str]] = None,\n pid_mode: Optional[str] = None,\n entrypoint: Optional[str] = None):\n if volumes is None:\n volumes = {}\n if dns is None:\n dns = []\n\n expose = []\n port_bindings = {}\n for port in ports.keys():\n if isinstance(port, tuple):\n proto = port[1] if len(port) == 2 else \"tcp\"\n key = \"%d/%s\" % (port[0], proto)\n else:\n key = port\n port_bindings[key] = ports[port]\n expose.append(port)\n\n result = self._client.create_container(\n name, command=command, environment=env,\n volumes=[volume['bind'] for volume in volumes.values()],\n ports=expose,\n entrypoint=entrypoint)\n\n container = result[\"Id\"]\n result = self._client.start(container, binds=volumes,\n port_bindings=port_bindings, dns=dns,\n pid_mode=pid_mode)\n response = self._client.inspect_container(container)\n return response","def create_lxd_container(public_key=None, name=\"test_name\"):\n container = None\n\n # Format name so it's valid\n name = name.replace(\"_\", \"-\").replace(\".\", \"\")\n\n client = get_lxd_client()\n if not client:\n raise Exception(\"Unable to connect to LXD\")\n\n test_machine = \"test-{}-{}\".format(\n uuid.uuid4().hex[-4:],\n name,\n )\n\n private_key_path, public_key_path = find_n2vc_ssh_keys()\n\n try:\n # create profile w/cloud-init and juju ssh key\n if not public_key:\n public_key = \"\"\n with open(public_key_path, \"r\") as f:\n public_key = f.readline()\n\n client.profiles.create(\n test_machine,\n config={\n 'user.user-data': '#cloud-config\\nssh_authorized_keys:\\n- {}'.format(public_key)},\n devices={\n 'root': {'path': '/', 'pool': 'default', 'type': 'disk'},\n 'eth0': {\n 'nictype': 'bridged',\n 'parent': 'lxdbr0',\n 'type': 'nic'\n }\n }\n )\n except Exception as ex:\n debug(\"Error creating lxd profile {}: {}\".format(test_machine, ex))\n raise ex\n\n try:\n # create lxc machine\n config = {\n 'name': test_machine,\n 'source': {\n 'type': 'image',\n 'alias': 'xenial',\n 'mode': 'pull',\n 'protocol': 'simplestreams',\n 'server': 'https://cloud-images.ubuntu.com/releases',\n },\n 'profiles': [test_machine],\n }\n container = client.containers.create(config, wait=True)\n container.start(wait=True)\n except Exception as ex:\n debug(\"Error creating lxd container {}: {}\".format(test_machine, ex))\n # This is a test-ending failure.\n raise ex\n\n def wait_for_network(container, timeout=30):\n \"\"\"Wait for eth0 to have an ipv4 address.\"\"\"\n starttime = time.time()\n while(time.time() < starttime + timeout):\n time.sleep(1)\n if 'eth0' in container.state().network:\n addresses = container.state().network['eth0']['addresses']\n if len(addresses) > 0:\n if addresses[0]['family'] == 'inet':\n return addresses[0]\n return None\n\n try:\n wait_for_network(container)\n except Exception as ex:\n debug(\n \"Error waiting for container {} network: {}\".format(\n test_machine,\n ex,\n )\n )\n\n try:\n waitcount = 0\n while waitcount <= 5:\n if is_sshd_running(container):\n break\n waitcount += 1\n time.sleep(1)\n if waitcount >= 5:\n debug(\"couldn't detect sshd running\")\n raise Exception(\"Unable to verify container sshd\")\n\n except Exception as ex:\n debug(\n \"Error checking sshd status on {}: {}\".format(\n test_machine,\n ex,\n )\n )\n\n # HACK: We need to give sshd a chance to bind to the interface,\n # and pylxd's container.execute seems to be broken and fails and/or\n # hangs trying to properly check if the service is up.\n (exit_code, stdout, stderr) = container.execute([\n 'ping',\n '-c', '5', # Wait for 5 ECHO_REPLY\n '8.8.8.8', # Ping Google's public DNS\n '-W', '15', # Set a 15 second deadline\n ])\n if exit_code > 0:\n # The network failed\n raise Exception(\"Unable to verify container network\")\n\n return container","def start_container(client, work_package, load_saved):\n package_path = os.path.join(PATH, \"work_packages\")\n\n client.containers.run(image=\"scrape_light\",\n environment=[\"PACKAGE=\"+work_package, \"LOAD_FILE=\" + load_saved,\n \"USERNAME=patrick.kalmbach@tum.de\", \"PASSWORD=LA#kYs1#o:`Z\"],\n detach=True, tty=True, stdin_open=True,\n sysctls={\"net.ipv4.conf.all.rp_filter\": 2},\n privileged=True,\n devices=[\"/dev/net/tun\"],\n name=\"scrape_\" + str(work_package),\n cap_add=[\"NET_ADMIN\", \"SYS_MODULE\"],\n volumes={package_path: {\"bind\": \"/work_packages\"}})","def _create_container_registry_secret(self):\n if not all(key in self.k8s_config for key in [\"docker_user\", \"docker_password\"]):\n return\n\n logger.debug('Creating container registry secret')\n docker_server = self.k8s_config.get('docker_server', 'https://index.docker.io/v1/')\n docker_user = self.k8s_config.get('docker_user')\n docker_password = self.k8s_config.get('docker_password')\n\n cred_payload = {\n \"auths\": {\n docker_server: {\n \"Username\": docker_user,\n \"Password\": docker_password\n }\n }\n }\n\n data = {\n \".dockerconfigjson\": base64.b64encode(\n json.dumps(cred_payload).encode()\n ).decode()\n }\n\n secret = client.V1Secret(\n api_version=\"v1\",\n data=data,\n kind=\"Secret\",\n metadata=dict(name=\"lithops-regcred\", namespace=self.namespace),\n type=\"kubernetes.io/dockerconfigjson\",\n )\n\n try:\n self.core_api.delete_namespaced_secret(\"lithops-regcred\", self.namespace)\n except ApiException as e:\n pass\n\n try:\n self.core_api.create_namespaced_secret(self.namespace, secret)\n except ApiException as e:\n if e.status != 409:\n raise e","def createContainer(tag, data={}): #@NoSelf","def run(self, container_config: ContainerConfig) -> Container:","def create(self, image, command=None, **kwargs):\n if isinstance(image, Image):\n image = image.id\n kwargs['image'] = image\n kwargs['command'] = command\n kwargs['version'] = self.client.api._version\n create_kwargs = _create_container_args(kwargs)\n resp = self.client.api.create_container(**create_kwargs)\n return self.get(resp['Id'])","def _create_container(self, docker_client: \"DockerClient\", **kwargs) -> \"Container\":\n # Create the container with retries on name conflicts (with an incremented idx)\n index = 0\n container = None\n name = original_name = kwargs.pop(\"name\")\n\n while not container:\n from docker.errors import APIError\n\n try:\n display_name = repr(name) if name else \"with auto-generated name\"\n self.logger.info(f\"Creating Docker container {display_name}...\")\n container = docker_client.containers.create(name=name, **kwargs)\n except APIError as exc:\n if \"Conflict\" in str(exc) and \"container name\" in str(exc):\n self.logger.info(\n f\"Docker container name {display_name} already exists; \"\n \"retrying...\"\n )\n index += 1\n name = f\"{original_name}-{index}\"\n else:\n raise\n\n self.logger.info(\n f\"Docker container {container.name!r} has status {container.status!r}\"\n )\n return container","def _newcontainer(self, siginfo):\n self.logger.log('creating a new %s with siginfo %r' % (self.cname, (siginfo, )))\n if self.ourcontainer:\n self.logger.log('freeing previously loaded %s' % (self.cname))\n self.announcequeue.append(self.ourcontainer)\n self.ourcontainer.save()\n self.ourcontainer.complete = True\n self.session.add(self.ourcontainer)\n\n self.ourcontainer = self.container(self.config.owner, self.config, siginfo=siginfo)\n self.ourcontainer.create(int(self.config.container_manager.maxcapacity))\n self.ourcontainer.save()\n self.logger.log(\"New %s's filename: %s\" % (self.cname, self.ourcontainer.filename))","def DeployContainerService(self, name, container_spec):\n service = KubernetesContainerService(container_spec, name)\n self.services[name] = service\n service.Create()","def container(self, image: str, **kwargs) -> container.Container:\n raise NotImplementedError","def start_container(self):\n logger = logging.getLogger(self.dkr_name)\n logger.info(\"Starting up container\")\n\n try:\n svc = self.docker_client().containers.get(self.dkr_name)\n except Exception:\n svc = self.docker_client().containers.run(image=self.dkr_image,\n name=self.dkr_name,\n command=self.dkr_command,\n ports=self.dkr_ports,\n links=self.dkr_links,\n environment=self.dkr_env,\n detach=True,\n remove=self.dkr_remove)\n\n while svc.status != \"running\":\n svc.reload()\n sleep(1)\n\n self.dkr_container = svc","def create(self, resource):\r\n self._load_resource(resource)\r\n blob_folder = self._blob_folder()\r\n if is_folder(blob_folder):\r\n logger.warning(self._context(\"Container already exists\"))\r\n else:\r\n # create new container\r\n logger.info(self._context(\"Creating container\"))\r\n create_folder(blob_folder)\r\n\r\n self.disconnect()\r\n return is_folder(blob_folder)","def factory(container, name, factory):","def ddtest_create_rsa_container_w_name(self, name=None):\n secret_urls = self.secret_behaviors.create_n_secrets(3)\n container_resp = self.behaviors.create_rsa_container(\n name, secret_urls[0], secret_urls[1], secret_urls[2])\n self._check_container_create_response(container_resp)\n\n get_resp = self.container_client.get_container(container_resp.ref)\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\n name=name, type='rsa')","def request_new_instance( self ):\n\n request_id = self.az_commands.invoke( \"add\",\n background=True,\n bg_callback=self.process_new_instance,\n name=\"{0}-{1}\".format( self.instance_name, self.next_host_id ),\n registrypassword=self.docker_auth,\n image=self.instance_type,\n query=\"'{id:id, name:name, ip:ipAddress.ip, type:containers[0].image, status:provisioningState}'\")[0]\n\n # create a new host object\n hobj = hostObject.HostObject(self.next_host_id, hostObject.HostObject.TYPE_CONTAINER)\n\n self.active_request[ request_id ] = hobj\n self.instances.append( hobj )\n\n self.next_host_id += 1","def create_node(self, **kwargs):\n default = \"ubuntu.precise\"\n template = {\"name\":\"ubuntu\", \"args\":[]}\n if 'image' not in kwargs:\n kwargs['image'] = default\n \n for image in self.list_images():\n if image.name == kwargs['image']:\n template = {\"name\":image.extra[\"template_name\"],\n \"args\":image.extra[\"template_args\"]\n }\n \n name = kwargs['name']\n container = {\n \"cgroups\": [],\n \"name\": name,\n \"conf\": [],\n \"template\": template\n }\n \n self.connection.request(action=\"/v1/containers\", method=\"POST\", data=json.dumps(container))\n self.connection.request(action=\"/v1/containers/%s/actions/start\" % name, method=\"POST\")\n return self.get_node(name)","def _constructInstance(self, container, id, *args, **kw):\n file, title = None, ''\n id = container.manage_addProduct['OFSP'].manage_addImage(id, file, title)\n return container.get(id, None)","def docker_container():\n if SETUP_SPLASH:\n dm = DockerManager()\n dm.start_container()\n\n try:\n requests.post('{}/_gc'.format(SPLASH_URL))\n except requests.exceptions.RequestException:\n pass\n\n yield","def create_and_init_container( # noqa pylint: disable=too-many-arguments\n self,\n image: docker.models.images.Image,\n container_name: str,\n target_adapter: Type['BaseTargetAdapter'],\n source_adapter: str,\n network: docker.models.networks.Network,\n replica_volume: docker.models.volumes.Volume,\n envars: dict\n ) -> docker.models.containers.Container:\n\n logger.info(\n f\"Creating stopped container {container_name}...\")\n\n port = target_adapter.DOCKER_TARGET_PORT\n hostname = target_adapter.credentials.host\n protocol = 'tcp'\n port_dict = {f\"{str(port)}/{protocol}\": port}\n\n self.remove_container(container_name)\n\n container = self.client.containers.create(\n image.tags[0],\n target_adapter.DOCKER_START_COMMAND,\n network=network.name,\n name=container_name,\n hostname=hostname,\n ports=port_dict,\n environment=envars,\n labels=dict(\n snowshu_replica='true',\n target_adapter=target_adapter.CLASSNAME,\n source_adapter=source_adapter),\n detach=True,\n volumes={replica_volume.name: {\n 'bind': f'{DOCKER_REPLICA_MOUNT_FOLDER}'\n }},\n working_dir=DOCKER_WORKING_DIR\n )\n logger.info(\n f\"Created stopped container {container.name}, connecting it to bridge network...\")\n self._connect_to_bridge_network(container)\n logger.info(\n f'Connected. Starting created container {container.name}...')\n try:\n container.start()\n except docker.errors.APIError as error:\n if 'port is already allocated' in error.explanation:\n logger.exception('One of the ports used by snowshu_target is '\n 'already allocated, stop extra containers and rerun')\n raise\n logger.info(\n f'Container {container.name} started, running initial setup...')\n self._run_container_setup(container, target_adapter)\n logger.info(f'Container {container.name} fully initialized.')\n\n return container","def test_rackspace_uploader_creates_container(self, mock, mock2):\r\n with patch('pybossa.uploader.rackspace.pyrax.cloudfiles') as mycf:\r\n mycf.get_container.side_effect = NoSuchContainer\r\n mycf.create_container.return_value = True\r\n mycf.make_container_public.return_value = True\r\n u = RackspaceUploader()\r\n res = u.init_app(self.flask_app)\r\n err_msg = \"Init app should return the container.\"\r\n assert res is True, err_msg","def create_container(cls, values):\n dbdriver = get_instance()\n return dbdriver.create_container(values)","def start(self) -> None:\r\n # --ulimit nofile=<soft limit>:<hard limit> set the limit for open files\r\n docker_run_command = ('docker run --ulimit nofile=65535:65535 -td -p %d:8545 -p %d:30303 --rm --name %s %s' %\r\n (self.rpc_port, self.ethereum_network_port, self.name, IMAGE))\r\n sleep(0.6)\r\n result = self.ip.exec_command(docker_run_command)\r\n if result:\r\n if result.startswith('docker: Error'):\r\n print(result)\r\n print(self.ip)\r\n raise RuntimeError('An error occurs while starting docker container. Container maybe already exists')\r\n print('container of node %s of blockchain %s at %s:%s started' % (self.node_index, self.blockchain_id,\r\n self.ip.address, self.rpc_port))\r\n new_account_command = 'docker exec -t %s geth --datadir abc account new --password passfile' % self.name\r\n sleep(0.1)\r\n account = self.ip.exec_command(new_account_command).split()[-1][1:-1]\r\n sleep(0.3)\r\n if len(account) == 40: # check if the account is valid\r\n self.accounts.append(account)\r\n else:\r\n print('invalid account')","def _update_container(self):\n client = docker.from_env()\n self.container = client.containers.get(self.session.container_id)","def ddtest_create_container_w_secret_name(self, name=None):\n # create a container with a particular secret name\n responses = self.behaviors.create_container_with_secret(\n name='name', secret_name=name)\n secret_resp, container_resp = responses\n self._check_container_create_response(container_resp)\n\n # verify the container exists with the expected data\n get_resp = self.container_client.get_container(container_resp.ref)\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\n name='name', type='generic',\n num_secrets=1)\n\n # verify the secret's name is returned correctly\n secret_ref = get_resp.entity.secret_refs[0]\n self.assertEqual(secret_ref.name, name)","def _launch_local_catalog():\n open_config = api._config()\n command = [\"docker\", \"run\", \"--rm\"]\n env = dict(REGISTRY_URL=\"http://localhost:5000\",\n S3_PROXY_URL=\"http://localhost:5002\",\n ALWAYS_REQUIRE_AUTH=\"false\",\n CATALOG_MODE=\"LOCAL\",\n SSO_AUTH=\"DISABLED\",\n PASSWORD_AUTH=\"ENABLED\",\n API_GATEWAY=open_config[\"apiGatewayEndpoint\"],\n BINARY_API_GATEWAY=open_config[\"binaryApiGatewayEndpoint\"])\n for var in [f\"{key}={value}\" for key, value in env.items()]:\n command += [\"-e\", var]\n command += [\"-p\", \"3000:80\", \"quiltdata/catalog\"]\n subprocess.Popen(command)","def _create(self, variables):\n required_vars = ['container']\n variables_dict = self._get_vars(variables, required=required_vars)\n\n container_name = variables_dict.pop('container')\n container_data = self._create_container(container_name=container_name)\n\n if not container_data:\n container_data = self.swift.head_container(container_name)\n\n return self._facts(facts=[container_data])","def ddtest_create_generic_container_w_empty_or_null_name(self, name=None):\n if name is None:\n self._skip_on_issue('launchpad', '1354767')\n\n container_resp = self.behaviors.create_container(name, 'generic', [])\n self._check_container_create_response(container_resp)\n\n get_resp = self.container_client.get_container(container_resp.ref)\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\n name=container_resp.id, type='generic')","def setup(self):\n\n exists = [i for i in self.client.images() if self.image in i['RepoTags']]\n\n # Only pull the image if we don't have it\n if not exists or self.pull:\n self.client.pull(self.image)\n self.logger.debug(\"Pulled {}\".format(self.image))\n\n self.container = self.client.create_container(\n image=self.image,\n host_config=self.host_config,\n name=self.name,\n command=self.command,\n environment=self.environment\n )\n self.logger.debug(\"Created container {}\".format(self.container['Id']))","def create(cls, name, container_object, enable=True, optional_attributes={}):\n assert type(name) == str\n assert container_object.__class__.__name__ == 'ADContainer'\n return container_object.create_computer(name=name,enable=enable,optional_attributes=optional_attributes)","def start(self, container: Container):","def create_metasploit_container(self, instance_id):\n all_containers_documents = self.database.get_docker_documents(amazon_resource_id=instance_id, type=self.type)\n\n new_container = ContainerOperations(\n docker_server_id=instance_id\n ).run_container_with_msfrpcd_metasploit(containers_documents=all_containers_documents)\n\n container_response = new_container_response(container=new_container)\n\n self.database.add_docker_document(\n amazon_resource_id=instance_id, docker_document_type=self.type, new_docker_document=container_response\n )\n\n return container_response","def test001_create_containers(self):\n self.log('%s STARTED' % self._testID)\n\n self.log('Create a two container on that node, should succeed.')\n self.cont1_name = self.random_string()\n self.containers = {self.cont1_name: {'hostname': self.cont1_name,\n 'flist': self.cont_flist,\n 'storage': self.cont_storage}}\n\n self.cont2_name = self.random_string()\n self.containers.update({self.cont2_name: {'hostname': self.cont2_name,\n 'flist': self.cont_flist,\n 'storage': self.cont_storage}})\n\n res = self.create_container(containers=self.containers, temp_actions=self.temp_actions)\n self.assertEqual(type(res), type(dict()))\n self.wait_for_service_action_status(self.cont1_name, res[self.cont1_name]['install'])\n self.wait_for_service_action_status(self.cont2_name, res[self.cont2_name]['install'])\n\n self.log('Check that the container have been created.')\n conts = self.zos_client.container.list()\n self.assertTrue([c for c in conts.values() if c['container']['arguments']['name'] == self.cont1_name])\n self.assertTrue([c for c in conts.values() if c['container']['arguments']['name'] == self.cont2_name])\n cont1 = [c for c in conts.values() if c['container']['arguments']['name'] == self.cont1_name][0]\n self.assertTrue(cont1['container']['arguments']['storage'], self.cont_storage)\n self.assertTrue(cont1['container']['arguments']['root'], self.cont_flist)\n self.assertTrue(cont1['container']['arguments']['hostname'], self.cont_flist)\n\n self.log('%s ENDED' % self._testID)","def __create__container(self):\n self.__used_containers.append(contenedor.Arena(self.__blocks_size))","def _put_container_on_host(self, container_name):\n with hide(\"output\", \"warnings\", \"running\"):\n # first see if container is already present on host\n host_result = self._execute_root(\n \"docker images -q {cn}\".format(cn=container_name))\n if len(host_result.stdout) > 0:\n print(\"Found %s on host\" % container_name)\n return True\n # now try to pull from Docker Hub\n hub_result = self._execute_root(\"docker pull {cn}\".format(cn=container_name),\n warn_only=True)\n if hub_result.return_code == 0:\n print(\"Found %s in Docker hub\" % container_name)\n return True\n\n # assume container_name refers to a local container and\n # copy it to host\n local_result = local(\n \"docker images -q {cn}\".format(cn=container_name))\n\n if len(local_result.stdout) > 0:\n saved_fname = container_name.replace(\"/\", \"_\")\n subprocess.call(\"docker save -o /tmp/{fn}.tar {cn}\".format(\n fn=saved_fname,\n cn=container_name))\n tar_loc = \"/tmp/{fn}.tar\".format(fn=saved_fname)\n self._execute_put(tar_loc, tar_loc)\n self._execute_root(\"docker load -i {loc}\".format(loc=tar_loc))\n # self._execute_root(\"docker tag {image_id} {cn}\".format(\n # image_id=image_id, cn=cn))\n # now check to make sure we can access it\n host_result = self._execute_root(\n \"docker images -q {cn}\".format(cn=container_name))\n if len(host_result.stdout) > 0:\n print(\"Successfuly copied %s to host\" % container_name)\n return True\n else:\n warn(\n \"Problem copying container %s to host\" %\n container_name)\n return False\n\n # out of options\n warn(\"Could not find %s, please try with a valid \"\n \"container docker image\")\n return False","def creating_container(self, service):\n self.sync_code(service=service)\n externals = [v.external for v in service.options['volumes']]\n for v in self.get_hotcode_volumes(service):\n if v.external not in externals:\n service.options['volumes'].append(v)","def start(self):\n if self.session.status == Session.SessionStatus.RUNNING:\n return\n self._make_fifo()\n client = docker.from_env()\n\n volumes = {}\n if self.session.notebook:\n volumes.update(get_accessible_datasets_mount_dict(self.session.notebook))\n volumes.update({self.fifo_path: {\"bind\": f\"/{self.fifo_name}\"}})\n\n self.container = client.containers.run(\n \"m.docker-registry.ir/python:3.8-slim-buster\",\n [\"sh\", \"-c\", f\"python -i -u <>/{self.fifo_name}\"],\n stdin_open=True,\n detach=True,\n volumes=volumes\n )\n self.session.container_id = str(self.container.id)\n self.session.status = Session.SessionStatus.RUNNING\n self.session.run_counter = 1\n self.session.save()","def _process_createContainer(self, data):\r\n try:\r\n self._avatar.createContainer(data['containerTag'],\r\n data.get('containerData', {}))\r\n except KeyError as e:\r\n raise InvalidRequest(\"Can not process 'CreateContainer' request. \"\r\n 'Missing key: {0}'.format(e))","def create_container(self, image=None, tag=None):\n if image is not None:\n image_name = image.tags[0]\n elif tag is not None:\n image_name = self.build_image_name(tag)\n else:\n raise ValueError('No image or tag to run')\n\n return self.client.containers.create(image_name,\n privileged=True,\n detach=True,\n name='acrobat',\n volumes={'/dev/acrobat/fc': {'bind': '/dev/acrobat/fc', 'mode': 'rw'},\n '/dev/acrobat/radio': {'bind': '/dev/acrobat/radio', 'mode': 'rw'},\n '/media/acrobat/logs': {'bind': '/logs', 'mode': 'rw'}})","def machine_new(node=\"dev\", driver='virtualbox'):\n machine = Dockerizing(driver)\n\n # Check that the requested node does not already exist\n if node in machine.list():\n print(colors.warn | \"Failed:\", colors.bold |\n \"Machine '%s' Already exists\" % node)\n return\n machine.create(node)\n\n # Create the machine\n _logger.info(\"Preparing machine\", node)\n print(machine.create(node))\n _logger.info(colors.green | \"Created!\\n\\n\")","def DeployContainerService(self, name, container_spec, num_containers):\n raise NotImplementedError()","def create(self, name, image, fetch_image=False, network=None, volumes={},\n **kwargs):\n create_kwargs = {\n 'detach': True,\n }\n\n # Convert network & volume models to IDs\n network = self._network_for_container(network, kwargs)\n if network is not None:\n network_id, network = (\n self._network_helper._get_id_and_model(network))\n create_kwargs['network'] = network_id\n\n if volumes:\n create_kwargs['volumes'] = self._volumes_for_container(volumes)\n\n create_kwargs.update(kwargs)\n\n if fetch_image:\n self._image_helper.fetch(image)\n\n container = super().create(name, image, **create_kwargs)\n\n if network is not None:\n self._connect_container_network(container, network, aliases=[name])\n\n return container","def create(self, execution_script, arguments, more_than_one):\n container_create_time = timer()\n\n client = docker.from_env(timeout=60)\n\n mount = {\n self.directory: {\n 'bind': self.directory,\n 'mode': 'rw'\n }\n }\n\n # Only pass container name to testcases with greater than one container.\n # (Doing otherwise breaks compilation)\n container_name_argument = ['--container_name', self.name] if more_than_one else []\n # A server container does not run student code, but instead hosts\n # a service (i.e. a database.)\n\n try:\n if self.is_server:\n self.container = client.containers.create(\n self.image,\n stdin_open=True,\n tty=True,\n network='none',\n volumes=mount,\n working_dir=self.directory,\n name=self.full_name\n )\n else:\n container_ulimits = rlimit_utils.build_ulimit_argument(\n self.container_rlimits,\n self.image\n )\n command = [execution_script, ] + arguments + container_name_argument\n self.container = client.containers.create(\n self.image,\n command=command,\n ulimits=container_ulimits,\n stdin_open=True,\n tty=True,\n network='none',\n user=self.container_user_argument,\n volumes=mount,\n working_dir=self.directory,\n hostname=self.name,\n name=self.full_name\n )\n except docker.errors.ImageNotFound:\n self.log_function(f'ERROR: The image {self.image} is not available on this worker')\n client.close()\n raise\n except Exception:\n self.log_function(f'ERROR: could not create container {self.full_name}')\n client.close()\n raise\n\n self.log_container(\n 'CREATED',\n self.full_name,\n self.container.short_id,\n timer() - container_create_time\n )\n client.close()","def __create_cont(self, path, filesystem, cont_stat, component_number):\n try:\n self.logger.debug('Create container interface called')\n status_obj = Status()\n cont_id = \"container\"\n #cont_id = get_container_id()\n tmp_path = '%s/%s/%s/%s/%s' % (self.__fs_base, \\\n filesystem, TMPDIR, cont_id,component_number)\n self.asyn_helper.call(\"create_container\", \\\n tmp_path, path, cont_stat, status_obj)\n return status_obj\n except Exception as err:\n self.logger.error(('create_container for %(con_dir)s failed ',\n 'close failure: %(exc)s : %(stack)s'),\n {'con_dir' : path, \n 'exc': err, 'stack': ''.join(traceback.format_stack())})\n raise err","def launch_container(self, service_info):\n user, instance = _get_user_and_instance(\n self.girder_client, service_info['instanceId'])\n tale = self.girder_client.get(f\"/tale/{service_info['taleId']}\")\n\n self.job_manager.updateProgress(\n message='Starting container', total=LAUNCH_CONTAINER_STEP_TOTAL,\n current=1, forceFlush=True)\n\n print(\"Launching container for a Tale...\")\n if 'imageInfo' not in tale:\n\n # Wait for image to be built\n tic = time.time()\n timeout = 180.0\n time_interval = 5\n\n while time.time() - tic < timeout:\n tale = self.girder_client.get('/tale/{taleId}'.format(**instance))\n if 'imageInfo' in tale and 'digest' in tale['imageInfo']:\n break\n msg = f\"Waiting for image build to complete. ({time_interval}s)\"\n logging.info(msg)\n print(msg)\n time.sleep(5)\n\n container_config = _get_container_config(self.girder_client, tale)\n service, attrs = _launch_container(service_info, container_config)\n print(\n f\"Started a container using volume: {service_info['volumeName']} \"\n f\"on node: {service_info['nodeId']}\"\n )\n\n # wait until task is started\n tic = time.time()\n timeout = 300.0\n started = False\n\n print(\"Waiting for the environment to be accessible...\")\n while time.time() - tic < timeout:\n try:\n status = service.tasks()[0]['Status']\n\n if status['State'] in {\"failed\", \"rejected\"}:\n raise ValueError(\"Failed to start environment: %s\" % status['Err'])\n elif status['State'] == \"running\":\n started = True\n break\n\n except IndexError:\n started = False\n\n time.sleep(0.2)\n\n if not started:\n raise ValueError(\"Tale did not start before timeout exceeded\")\n\n print(\"Environment is up and running.\")\n self.job_manager.updateProgress(\n message='Container started', total=LAUNCH_CONTAINER_STEP_TOTAL,\n current=LAUNCH_CONTAINER_STEP_TOTAL, forceFlush=True)\n\n service_info.update(attrs)\n service_info['name'] = service.name\n return service_info","def createContainer(self, user, dataSet):\n\n dmSession = Session()\n session = dmSession.createSession(user, dataSet)\n\n container = {\n '_id': objectid.ObjectId(),\n 'ownerId': user['_id'],\n 'status': 'Starting',\n 'sessionId': session['_id']\n }\n\n self.setUserAccess(container, user = user, level = AccessType.ADMIN)\n\n container = self.save(container)\n\n self.startContainer(user, container)\n logger.info(\"Container \" + str(container['_id']) + \" started\")\n\n return container","def get_container(self, name):\r\n try:\r\n return self.cf.get_container(name)\r\n except pyrax.exceptions.NoSuchContainer:\r\n c = self.cf.create_container(name)\r\n self.cf.make_container_public(name)\r\n return c","def containers_init(self):\n\n def test_container(name, state, status):\n \"\"\"Creates test container. \"\"\"\n return {\n 'Image': \"alpine:3.7\",\n 'Command': \"/bin/sleep 999\",\n 'Labels': {'out': ''},\n 'State': state,\n 'Created': 1524205394,\n 'Status': status,\n 'Names': [\"/\" + name]\n }\n\n state_created = 'created'\n state_running = 'running'\n\n status_created = 'Created'\n status_up = 'Up 15 minutes'\n\n self.containers_list = [\n test_container(self.container_to_run,\n state_created, status_created),\n test_container(self.container_running,\n state_running, status_up),\n test_container(self.container_to_remove,\n state_created, status_created),\n ]\n\n CLIENT.containers_list.extend(self.containers_list)","def _create_container(self, finding):\n\n container_dict = {}\n container_dict['name'] = finding['Title']\n container_dict['source_data_identifier'] = finding['Id']\n container_dict['description'] = finding['Description']\n\n container_creation_status, container_creation_msg, container_id = self.save_container(container=container_dict)\n\n if phantom.is_fail(container_creation_status):\n self.debug_print(container_creation_msg)\n self.save_progress('Error while creating container for finding {finding_id}. '\n '{error_message}'.format(finding_id=finding['Id'],\n error_message=container_creation_msg))\n return None\n\n return container_id","def test_create_container_privilege(self):\n pass","def create_registry_secret(secret_name, docker_registry, docker_username, docker_password, namespace):\n add_registry_completed = run([\"kubectl\", \"create\", \"secret\", \"docker-registry\", secret_name,\n \"--docker-server=%s\" % docker_registry,\n \"--docker-username=%s\" % docker_username,\n \"--docker-password=%s\" % docker_password,\n \"--namespace=%s\" % namespace],\n stdout=PIPE,\n stderr=PIPE)\n if add_registry_completed.returncode == 0:\n value = add_registry_completed.stdout.decode('utf-8').strip()\n else:\n value = add_registry_completed.stderr.decode('utf-8').strip()\n\n return {'returncode': add_registry_completed.returncode, 'value': value}","def _restart(self, docker_image_name):\n if self.docker_repo:\n docker_image_name = '%s/%s' % (self.docker_repo,\n docker_image_name)\n\n docker_container_name = '%s_%s' % (self.docker_image_name_prefix,\n self.scope)\n\n mounts = [\n DockerMount('/dev/log', '/dev/log', type='bind'),\n DockerMount(self.paths.sandbox_pipe_dir,\n self.paths.host_pipe_dir,\n type='bind'),\n DockerMount(self.paths.sandbox_storlet_base_dir,\n self.paths.host_storlet_base_dir,\n type='bind'),\n DockerMount(self.paths.sandbox_storlet_native_lib_dir,\n self.paths.host_storlet_native_lib_dir,\n type='bind', read_only=True),\n DockerMount(self.paths.sandbox_storlet_native_bin_dir,\n self.paths.host_storlet_native_bin_dir,\n type='bind', read_only=True)\n ]\n\n try:\n client = docker.from_env()\n # Stop the existing storlet container\n try:\n scontainer = client.containers.get(docker_container_name)\n except docker.errors.NotFound:\n # The container is not yet created\n pass\n else:\n scontainer.stop(timeout=self.sandbox_stop_timeout)\n\n # Check whether a new container can be started\n if self.max_containers_per_node > 0:\n all_scontainers = client.containers.list(\n filters={'label': 'managed_by=storlets'})\n if len(all_scontainers) >= self.max_containers_per_node:\n raise StorletRuntimeException(\n \"Cannot start a container because of limit\")\n\n # Start the new one\n client.containers.run(\n docker_image_name, detach=True, name=docker_container_name,\n network_disabled=True, mounts=mounts, user='swift',\n auto_remove=True, stop_signal='SIGHUP',\n labels={'managed_by': 'storlets'})\n except docker.errors.ImageNotFound:\n msg = \"Image %s is not found\" % docker_image_name\n raise StorletRuntimeException(msg)\n except docker.errors.APIError:\n self.logger.exception(\"Failed to manage docker containers\")\n raise StorletRuntimeException(\"Docker runtime error\")","def create(self, name, containerFormat, diskFormat, isPublic, pathFile):\n if isPublic:\n isPublic = \"public\"\n else:\n isPublic = \"private\"\n\n image = self.client.images.create(name=name, container_format=containerFormat, disk_format=diskFormat, is_public=isPublic)\n # Thread ?\n self.client.images.upload(image.id, open(pathFile, 'rb'))\n while image.status == \"queued\":\n image = self.find(image_id=image.id)\n time.sleep(1)\n return self.find(image_id=image.id)","def GenerateContainer(ctx, \n container_name=None, \n container_iname=None,\n base_interfaces=()\n ):\n # create container\n container_name = container_name or \\\n \"%sContainer\" % (ctx.domain_model.__name__)\n \n # allow passing in dotted python path\n if isinstance(ctx.container_module, (str, unicode)):\n ctx.container_module = resolve(ctx.container_module)\n \n # if not present use the domain class's module\n elif ctx.container_module is None:\n ctx.container_module = resolve(ctx.domain_model.__module__)\n \n # sanity check we have a module for the container\n assert isinstance(ctx.container_module, types.ModuleType), \"Invalid Container\"\n \n # logging variables\n msg = (ctx.domain_model.__name__, \n ctx.container_module.__name__, container_name)\n \n # if we already have a container class, exit \n if getattr(ctx.container_module, container_name, None):\n if ctx.echo:\n ctx.logger.debug(\"%s: found container %s.%s, skipping\" % msg)\n ctx.container_class = getattr(ctx.container_module, container_name)\n return\n \n if ctx.echo:\n ctx.logger.debug(\"%s: generated container %s.%s\" % msg)\n \n # if we already have a container class, exit\n container_class = type(container_name,\n (AlchemistContainer,),\n dict(_class=ctx.domain_model,\n __module__=ctx.container_module.__name__)\n )\n setattr(ctx.container_module, container_name, container_class)\n \n # save container class on catalyst context\n ctx.container_class = container_class\n \n # interface for container\n container_iname = container_iname or \"I%s\" % container_name\n \n # if the interface module is none, then use the nearest one to the domain class\n if ctx.interface_module is None:\n ctx.interface_module = _get_interface_module_for(ctx)\n\n msg = (ctx.domain_model.__name__,\n ctx.container_module.__name__, container_iname)\n \n # if we already have a container interface class, skip creation\n container_interface = getattr(ctx.interface_module, container_iname, None)\n if container_interface is not None:\n assert issubclass(container_interface, IAlchemistContainer)\n if ctx.echo:\n ctx.logger.debug(\"%s: skipping container interface %s.%s for\" % msg)\n else:\n if ctx.echo:\n ctx.logger.debug(\"%s: generated container interface %s.%s\" % msg)\n # ensure that our base interfaces include alchemist container \n if base_interfaces:\n assert isinstance(base_interfaces, tuple)\n found = False\n for bi in base_interfaces:\n found = issubclass(bi, IAlchemistContainer)\n if found: break\n if not found:\n base_interfaces = base_interfaces + (IAlchemistContainer,)\n else:\n base_interfaces = (IAlchemistContainer,)\n \n # create interface\n container_interface = interface.interface.InterfaceClass(\n container_iname,\n bases=base_interfaces,\n __module__=ctx.interface_module.__name__\n )\n # store container interface for catalyst\n ctx.container_interface = container_interface\n setattr(ctx.interface_module, container_iname, container_interface)\n \n # setup security\n for n,d in container_interface.namesAndDescriptions(1):\n protectName(container_class, n, \"zope.Public\")\n \n if not container_interface.implementedBy(container_class):\n interface.classImplements(container_class, container_interface)\n ctx.container_interface = container_interface","def get_container_by_name(self, container_name, is_source):\n if container_name not in self.containers:\n self.containers[container_name] = self.create_container(container_name, is_source)\n return self.containers[container_name]","def test_container_cycle(self):\n # Before Create\n print(\"Create\")\n rep = post(self.url + \"/search\", data={'name': name})\n self.errorCatch(rep)\n\n # Create\n rep = post(self.url + \"/create\", data={\n 'image': default_image,\n 'homepath': \"/nashome/guest/test\",\n 'naspath': \"/home/nas/test\",\n 'command': \"tail -f /dev/null\",\n 'name': name})\n self.checkRunning()\n\n # Double create\n rep = post(self.url + \"/create\", data={\n 'image': default_image,\n 'homepath': \"/nashome/guest/test\",\n 'naspath': \"/home/nas/test\",\n 'command': \"tail -f /dev/null\",\n 'name': name})\n self.errorCatch(rep)\n\n # Check by api\n con = client.containers.get(name)\n self.assertIn(\"tmp0\", con.exec_run(\"ls /home/nas\").output.decode())\n self.assertIn(\"tmp1\", con.exec_run(\"ls /home/ubuntu\").output.decode())\n self.assertEqual(con.status, \"running\")\n\n # Stop\n con.exec_run(\"touch /opt/tmp2\").output.decode()\n print(\"Stop\")\n rep = post(self.url + \"/stop\", data={'name': name})\n self.checkOK(rep)\n\n # check stop\n rep = post(self.url + \"/search\", data={'name': name})\n self.checkOK(rep)\n rep = rep.json()\n self.assertIsInstance(rep[\"data\"], dict)\n self.assertEqual(rep['data']['status'], \"exited\")\n\n # start\n print(\"Resume\")\n rep = post(self.url + \"/start\", data={'name': name})\n self.checkOK(rep)\n self.checkRunning()\n con = client.containers.get(name)\n self.assertIn(\"tmp2\", con.exec_run(\"ls /opt\").output.decode())\n\n # change pw\n print(\"Change Password\")\n con.exec_run(\"adduser ubuntu\")\n rep = post(self.url + \"/passwd\", data={'name': name,\n 'pw': \"tmpPW\"})\n self.checkOK(rep)\n self.assertIn(\"tmpPW\", con.exec_run(\"cat /etc/shadow\").output.decode())\n\n # commit\n print(\"Commit\")\n rep = post(self.url + \"/commit\", data={'name': name,\n 'newname': name})\n self.checkOK(rep)\n\n # search image\n rep = post(self.url + \"/search/image\", data={'name': name})\n rep = rep.json()\n self.assertIsInstance(rep['data'], dict)\n\n # delete\n print(\"Delete\")\n rep = post(self.url + \"/delete\", data={'name': name})\n self.checkOK(rep)\n\n # check delete\n rep = post(self.url + \"/search\", data={'name': name})\n self.errorCatch(rep)\n\n # Delete Image\n print(\"Delete Image\")\n rep = post(self.url + \"/delete/image\", data={'name': name})\n self.checkOK(rep)\n\n # Check if delete it\n rep = post(self.url + \"/search/image\", data={'name': name})\n self.errorCatch(rep)","def execute(self, container_name, *args):\n execution = self.docker.exec_create(container=container_name,\n cmd=args,\n tty=True)\n\n return self.docker.exec_start(exec_id=execution['Id'])","def CreateDataContainer(name):\n dc = simpl.DataContainer.New(name)\n return dc","def _register_container(self, container):\n found = False\n try:\n for host, location, container in Container.Container.host_generator(container,\n known_networks=self.networks.keys()):\n websocket = \"ws\" in host.scheme or \"wss\" in host.scheme\n secured = 'https' in host.scheme or 'wss' in host.scheme\n http = 'http' in host.scheme or 'https' in host.scheme\n # it might return string if there's a error in processing\n if type(host) is not str:\n if (host.hostname, host.port) in self.hosts:\n existing_host: Host = self.hosts[(host.hostname, host.port)]\n existing_host.add_container(location, container, websocket=websocket, http=http)\n ## if any of the containers in for the virtualHost require https, the all others will be redirected to https.\n if secured:\n existing_host.secured = True\n host = existing_host\n else:\n host.secured = secured\n host.add_container(location, container, websocket=websocket, http=http)\n self.hosts[(host.hostname, host.port)] = host\n\n if host.secured:\n if host.hostname not in self.ssl_certificates:\n host.ssl_expiry = self.ssl.expiry_time(host.hostname)\n else:\n host.ssl_expiry = self.ssl_certificates[host.hostname]\n if (host.ssl_expiry - datetime.datetime.now()).days > 2:\n self.ssl_certificates[host.hostname] = host.ssl_expiry\n\n found = True\n self.containers.add(container.id)\n\n except Container.NoHostConiguration:\n print(\"Skip Container:\", \"No VIRTUAL_HOST configuration\", \"Id:\" + container.id,\n \"Name:\" + container.attrs[\"Name\"].replace(\"/\", \"\"), sep=\"\\t\")\n except Container.UnreachableNetwork:\n print(\"Skip Container:\", \"UNREACHABLE Network \", \"Id:\" + container.id,\n \"Name:\" + container.attrs[\"Name\"].replace(\"/\", \"\"), sep=\"\\t\")\n return found","def container(self, container):\n if not container.is_public():\n container.make_public()\n self._container = container","def add(self, name, container):\n\n if name not in self.keys:\n self.keys[name] = container\n else:\n raise KeyError('key already exists')","def addDocker( self, name, **params ):\n defaults={'dimage': self.dimage, 'hostExchangeFolder': self.hostExchangeFolder}\n defaults.update(params)\n return self.addHost( name, cls=Docker, **defaults )","def __set_container_info(self):\n self.container = \"{}_{}_1\".format(self.build, self.service.lower())\n self.mysql_container = \"{}_{}-mysql_1\".format(self.build, self.service.lower())","def add_machine(args):\n session = Session()\n # the following is used to help with code completion\n env = Environment(name=args.environment)\n try:\n env = session.query(Environment).filter_by(name=args.environment).one()\n except NoResultFound:\n print \"ERROR: couldn't find environment %s\" % args.environment\n sys.exit(1)\n machine = PoolMachine(name=args.name, hostname=args.hostname, environment=env, online=True)\n session.add(machine)\n session.commit()\n print repr(machine)","def test_get_container(self):\n pass","def create_machine(request):\n\n params = params_from_request(request)\n cloud_id = request.matchdict['cloud']\n\n for key in ('name', 'size'):\n if key not in params:\n raise RequiredParameterMissingError(key)\n\n key_id = params.get('key')\n machine_name = params['name']\n location_id = params.get('location', None)\n image_id = params.get('image')\n if not image_id:\n raise RequiredParameterMissingError(\"image\")\n # this is used in libvirt\n disk_size = int(params.get('libvirt_disk_size', 4))\n disk_path = params.get('libvirt_disk_path', '')\n size_id = params['size']\n # deploy_script received as unicode, but ScriptDeployment wants str\n script = str(params.get('script', ''))\n # these are required only for Linode/GCE, passing them anyway\n image_extra = params.get('image_extra', None)\n disk = params.get('disk', None)\n image_name = params.get('image_name', None)\n size_name = params.get('size_name', None)\n location_name = params.get('location_name', None)\n ips = params.get('ips', None)\n monitoring = params.get('monitoring', False)\n networks = params.get('networks', [])\n docker_env = params.get('docker_env', [])\n docker_command = params.get('docker_command', None)\n script_id = params.get('script_id', '')\n script_params = params.get('script_params', '')\n post_script_id = params.get('post_script_id', '')\n post_script_params = params.get('post_script_params', '')\n async = params.get('async', False)\n quantity = params.get('quantity', 1)\n persist = params.get('persist', False)\n docker_port_bindings = params.get('docker_port_bindings', {})\n docker_exposed_ports = params.get('docker_exposed_ports', {})\n azure_port_bindings = params.get('azure_port_bindings', '')\n # hostname: if provided it will be attempted to assign a DNS name\n hostname = params.get('hostname', '')\n plugins = params.get('plugins')\n cloud_init = params.get('cloud_init', '')\n associate_floating_ip = params.get('associate_floating_ip', False)\n associate_floating_ip_subnet = params.get('attach_floating_ip_subnet',\n None)\n project_id = params.get('project', None)\n bare_metal = params.get('bare_metal', False)\n # bare_metal True creates a hardware server in SoftLayer,\n # whule bare_metal False creates a virtual cloud server\n # hourly True is the default setting for SoftLayer hardware\n # servers, while False means the server has montly pricing\n softlayer_backend_vlan_id = params.get('softlayer_backend_vlan_id', None)\n hourly = params.get('billing', True)\n job_id = params.get('job_id')\n job_id = params.get('job_id')\n # The `job` variable points to the event that started the job. If a job_id\n # is not provided, then it means that this is the beginning of a new story\n # that starts with a `create_machine` event. If a job_id is provided that\n # means that the current event will be part of already existing, unknown\n # story. TODO: Provide the `job` in the request's params or query it.\n if not job_id:\n job = 'create_machine'\n job_id = uuid.uuid4().hex\n else:\n job = None\n\n # these are needed for OnApp\n size_ram = params.get('size_ram', 256)\n size_cpu = params.get('size_cpu', 1)\n size_disk_primary = params.get('size_disk_primary', 5)\n size_disk_swap = params.get('size_disk_swap', 1)\n boot = params.get('boot', True)\n build = params.get('build', True)\n cpu_priority = params.get('cpu_priority', 1)\n cpu_sockets = params.get('cpu_sockets', 1)\n cpu_threads = params.get('cpu_threads', 1)\n port_speed = params.get('port_speed', 0)\n hypervisor_group_id = params.get('hypervisor_group_id')\n\n auth_context = auth_context_from_request(request)\n\n try:\n Cloud.objects.get(owner=auth_context.owner,\n id=cloud_id, deleted=None)\n except Cloud.DoesNotExist:\n raise NotFoundError('Cloud does not exist')\n\n # compose schedule as a dict from relative parameters\n if not params.get('schedule_type'):\n schedule = {}\n else:\n if params.get('schedule_type') not in ['crontab',\n 'interval', 'one_off']:\n raise BadRequestError('schedule type must be one of '\n 'these (crontab, interval, one_off)]'\n )\n if params.get('schedule_entry') == {}:\n raise RequiredParameterMissingError('schedule_entry')\n\n schedule = {\n 'name': params.get('name'),\n 'description': params.get('description', ''),\n 'action': params.get('action', ''),\n 'script_id': params.get('schedule_script_id', ''),\n 'schedule_type': params.get('schedule_type'),\n 'schedule_entry': params.get('schedule_entry'),\n 'expires': params.get('expires', ''),\n 'start_after': params.get('start_after', ''),\n 'max_run_count': params.get('max_run_count'),\n 'task_enabled': bool(params.get('task_enabled', True)),\n 'auth_context': auth_context.serialize(),\n }\n\n auth_context.check_perm(\"cloud\", \"read\", cloud_id)\n auth_context.check_perm(\"cloud\", \"create_resources\", cloud_id)\n tags = auth_context.check_perm(\"machine\", \"create\", None) or {}\n if script_id:\n auth_context.check_perm(\"script\", \"run\", script_id)\n if key_id:\n auth_context.check_perm(\"key\", \"read\", key_id)\n\n # Parse tags.\n try:\n mtags = params.get('tags') or {}\n if not isinstance(mtags, dict):\n if not isinstance(mtags, list):\n raise ValueError()\n if not all((isinstance(t, dict) and len(t) is 1 for t in mtags)):\n raise ValueError()\n mtags = {key: val for item in mtags for key, val in item.items()}\n tags.update(mtags)\n except ValueError:\n raise BadRequestError('Invalid tags format. Expecting either a '\n 'dictionary of tags or a list of single-item '\n 'dictionaries')\n\n args = (cloud_id, key_id, machine_name,\n location_id, image_id, size_id,\n image_extra, disk, image_name, size_name,\n location_name, ips, monitoring, networks,\n docker_env, docker_command)\n kwargs = {'script_id': script_id,\n 'script_params': script_params, 'script': script, 'job': job,\n 'job_id': job_id, 'docker_port_bindings': docker_port_bindings,\n 'docker_exposed_ports': docker_exposed_ports,\n 'azure_port_bindings': azure_port_bindings,\n 'hostname': hostname, 'plugins': plugins,\n 'post_script_id': post_script_id,\n 'post_script_params': post_script_params,\n 'disk_size': disk_size,\n 'disk_path': disk_path,\n 'cloud_init': cloud_init,\n 'associate_floating_ip': associate_floating_ip,\n 'associate_floating_ip_subnet': associate_floating_ip_subnet,\n 'project_id': project_id,\n 'bare_metal': bare_metal,\n 'tags': tags,\n 'hourly': hourly,\n 'schedule': schedule,\n 'softlayer_backend_vlan_id': softlayer_backend_vlan_id,\n 'size_ram': size_ram,\n 'size_cpu': size_cpu,\n 'size_disk_primary': size_disk_primary,\n 'size_disk_swap': size_disk_swap,\n 'boot': boot,\n 'build': build,\n 'cpu_priority': cpu_priority,\n 'cpu_sockets': cpu_sockets,\n 'cpu_threads': cpu_threads,\n 'port_speed': port_speed,\n 'hypervisor_group_id': hypervisor_group_id}\n if not async:\n ret = methods.create_machine(auth_context.owner, *args, **kwargs)\n else:\n args = (auth_context.owner.id, ) + args\n kwargs.update({'quantity': quantity, 'persist': persist})\n tasks.create_machine_async.apply_async(args, kwargs, countdown=2)\n ret = {'job_id': job_id}\n ret.update({'job': job})\n return ret","def create(credentials: ICredentials, expires=30, registry=None):","def __init__(__self__, *,\n container_registry_name: pulumi.Input[str],\n resource_group_name: pulumi.Input[str],\n instance_count: Optional[pulumi.Input[int]] = None,\n location: Optional[pulumi.Input[str]] = None,\n name: Optional[pulumi.Input[str]] = None,\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\n tier: Optional[pulumi.Input[str]] = None,\n virtual_network_subnet_id: Optional[pulumi.Input[str]] = None):\n pulumi.set(__self__, \"container_registry_name\", container_registry_name)\n pulumi.set(__self__, \"resource_group_name\", resource_group_name)\n if instance_count is not None:\n pulumi.set(__self__, \"instance_count\", instance_count)\n if location is not None:\n pulumi.set(__self__, \"location\", location)\n if name is not None:\n pulumi.set(__self__, \"name\", name)\n if tags is not None:\n pulumi.set(__self__, \"tags\", tags)\n if tier is not None:\n pulumi.set(__self__, \"tier\", tier)\n if virtual_network_subnet_id is not None:\n pulumi.set(__self__, \"virtual_network_subnet_id\", virtual_network_subnet_id)"],"string":"[\n \"def container(name, ostemplate, **kwargs):\\n if not openvz.exists(name):\\n ctid = openvz.get_available_ctid()\\n openvz.create(ctid, ostemplate=ostemplate, **kwargs)\\n openvz.set(ctid, name=name)\\n return Container(name)\",\n \"def _create_container(self, container_name):\\n try:\\n container = self.swift.head_container(container_name)\\n except client.ClientException:\\n self.swift.put_container(container_name)\\n else:\\n return container\",\n \"def test_create_container(self):\\n pass\",\n \"def create_container(ContainerName=None, Tags=None):\\n pass\",\n \"def create_container(self, container_name):\\n response = self.client.put_container(container_name)\\n return response\",\n \"def _start_instance(self, resource_handler):\\n log.debug('Starting container')\\n cli = resource_handler.cli\\n #host_config=cli.create_host_config(network_mode=self.network_mode)\\n container = cli.create_container(\\n image='{0.image}:{0.tag}'.format(self),\\n command=self.command,\\n #host_config=host_config,\\n environment=self.env\\n )\\n\\n cli.start(container.get('Id'))\\n log.debug('Started container [%s]', container)\\n return str(container)\",\n \"async def CreateContainer(self, *args):\\n # Create and configure a LXD container for use with a proxy charm.\\n (model, application, _, _) = args\\n\\n debug(\\\"[CreateContainer] {}\\\".format(args))\\n container = None\\n\\n try:\\n # Execute 'get-ssh-public-key' primitive and get returned value\\n uuid = await self.n2vc.ExecutePrimitive(\\n model,\\n application,\\n \\\"get-ssh-public-key\\\",\\n None,\\n )\\n\\n result = await self.n2vc.GetPrimitiveOutput(model, uuid)\\n pubkey = result['pubkey']\\n\\n container = create_lxd_container(\\n public_key=pubkey,\\n name=os.path.basename(__file__)\\n )\\n\\n return container\\n except Exception as ex:\\n debug(\\\"Error creating container: {}\\\".format(ex))\\n pass\\n\\n return None\",\n \"def _create_docker_container(self):\\n cwd = os.getcwd()\\n\\n # get a docker client\\n docker_client = docker.from_env()\\n docker_image = \\\"aca_build0:latest\\\"\\n mount_pnt = docker.types.Mount(\\\"/mnt/alcor-control-agent\\\",\\n f'''{cwd}/../..''',\\n type='bind')\\n\\n mount_modules = docker.types.Mount(\\\"/lib/modules\\\",\\n \\\"/lib/modules\\\",\\n type='bind')\\n\\n # Create the container in privileged mode\\n container = docker_client.containers.create(\\n docker_image, '/bin/bash', tty=True,\\n stdin_open=True, auto_remove=False, mounts=[mount_pnt, mount_modules],\\n privileged=True, cap_add=[\\\"SYS_PTRACE\\\"],\\n ports={str(aca_droplet.port_internal) + \\\"/tcp\\\": ('0.0.0.0', aca_droplet.port_external)},\\n security_opt=[\\\"seccomp=unconfined\\\"], name=self.id)\\n container.start()\\n container.reload()\\n\\n # Increment the static external port number counter\\n aca_droplet.port_external = aca_droplet.port_external + 1\\n\\n # Restart dependancy services\\n container.exec_run(\\\"/etc/init.d/rpcbind restart\\\")\\n container.exec_run(\\\"/etc/init.d/rsyslog restart\\\")\\n container.exec_run(\\\"ip link set dev eth0 up mtu 9000\\\")\\n\\n # We may need to restart ovs\\n # container.exec_run(\\\"/etc/init.d/openvswitch-switch restart\\\")\\n\\n # Create simlinks\\n container.exec_run(\\\"ln -s /mnt/alcor-control-agent/mizar/build/bin /trn_bin\\\")\\n container.exec_run(\\\"ln -s /mnt/alcor-control-agent/mizar/build/xdp /trn_xdp\\\")\\n container.exec_run(\\\"ln -s /sys/fs/bpf /bpffs\\\")\\n\\n container.exec_run(\\n \\\"ln -s /mnt/alcor-control-agent/build/ /aca_build\\\")\\n\\n # Run the transitd in the background\\n container.exec_run(\\\"/trn_bin/transitd \\\",\\n detach=True)\\n\\n # Enable debug and tracing for the kernel\\n container.exec_run(\\n \\\"mount -t debugfs debugfs /sys/kernel/debug\\\")\\n container.exec_run(\\n \\\"echo 1 > /sys/kernel/debug/tracing/tracing_on\\\")\\n\\n # Enable core dumps (just in case!!)\\n container.exec_run(\\\"ulimit -u\\\")\\n cmd = \\\"echo '/mnt/alcor-control-agent/mizar/core/core_{}_%e.%p' |\\\\\\n tee /proc/sys/kernel/core_pattern \\\".format(self.ip)\\n container.exec_run(cmd)\\n\\n self.container = container\\n self.ip = self.container.attrs['NetworkSettings']['IPAddress']\\n self.mac = self.container.attrs['NetworkSettings']['MacAddress']\",\n \"def container_factory(self, name):\",\n \"def container_factory(self, name):\",\n \"def container_factory(self, name):\",\n \"def container_factory(self, name):\",\n \"def container_factory(self, name):\",\n \"def register_this_container(cache, db):\\n\\n # Get container id.\\n # bash_command = \\\"\\\"\\\"head -1 /proc/self/cgroup|cut -d/ -f3\\\"\\\"\\\"\\n # output = str(subprocess.check_output(['bash','-c', bash_command]), \\\"utf-8\\\").strip()\\n\\n # logger.info(output)\\n\\n my_host_name = socket.gethostname()\\n my_ip = socket.gethostbyname(my_host_name)\\n cache[\\\"ip\\\"] = my_ip\\n cache[\\\"host\\\"] = my_host_name\\n\\n free_cpu, free_mem = get_resources()\\n\\n logger.info({\\\"host_name\\\": my_host_name, \\\"ip\\\": my_ip})\\n try:\\n pipe = db.pipeline()\\n pipe.sadd(SET_NAME, my_ip).hset(my_ip, mapping={\\\"host_id\\\": my_host_name, \\\"cpu\\\": free_cpu, \\\"mem\\\": free_mem})\\n pipe.execute()\\n except Exception as e:\\n logger.error(e)\\n raise e\",\n \"def createContainer(self, uid, userID, data):\\r\\n container = self._createContainer(data, userID)\\r\\n self._getMachine(container).assignContainer(container, uid)\\r\\n return container\",\n \"def create(dockerfile):\\n\\n path = os.path.dirname(dockerfile)\\n\\n container_name = input('Enter container name: ')\\n port = input('Enter port number to map TCP port 5000 in the container, to a port on the Docker host: ')\\n\\n try:\\n image = CLIENT.images.build(path=path, dockerfile=dockerfile, tag=\\\"my_app_image\\\")\\n # Run a container and map TCP port 5000 in the container to a given port on the Docker host.\\n container = CLIENT.containers.run('my_app_image', detach=True, ports={'5000/tcp': port},\\n name=container_name)\\n click.secho(\\\"Container created with name: {}. App is running \\\"\\n \\\"on http://0.0.0.0:{}/ on the host.\\\"\\n .format(container_name, port), bg='blue', fg='white')\\n except (docker.errors.APIError, TypeError, OSError) as err:\\n print(err)\",\n \"def post(self, run=False, **container_dict):\\n context = pecan.request.context\\n compute_api = pecan.request.compute_api\\n policy.enforce(context, \\\"container:create\\\",\\n action=\\\"container:create\\\")\\n\\n try:\\n run = strutils.bool_from_string(run, strict=True)\\n except ValueError:\\n msg = _('Valid run values are true, false, 0, 1, yes and no')\\n raise exception.InvalidValue(msg)\\n try:\\n container_dict['tty'] = strutils.bool_from_string(\\n container_dict.get('tty', False), strict=True)\\n container_dict['stdin_open'] = strutils.bool_from_string(\\n container_dict.get('stdin_open', False), strict=True)\\n except ValueError:\\n msg = _('Valid tty and stdin_open values are ''true'', '\\n '\\\"false\\\", True, False, \\\"True\\\" and \\\"False\\\"')\\n raise exception.InvalidValue(msg)\\n\\n # NOTE(mkrai): Intent here is to check the existence of image\\n # before proceeding to create container. If image is not found,\\n # container create will fail with 400 status.\\n images = compute_api.image_search(context, container_dict['image'],\\n True)\\n if not images:\\n raise exception.ImageNotFound(container_dict['image'])\\n container_dict['project_id'] = context.project_id\\n container_dict['user_id'] = context.user_id\\n name = container_dict.get('name') or \\\\\\n self._generate_name_for_container()\\n container_dict['name'] = name\\n if container_dict.get('memory'):\\n container_dict['memory'] = \\\\\\n str(container_dict['memory']) + 'M'\\n if container_dict.get('restart_policy'):\\n self._check_for_restart_policy(container_dict)\\n container_dict['status'] = fields.ContainerStatus.CREATING\\n new_container = objects.Container(context, **container_dict)\\n new_container.create(context)\\n\\n if run:\\n compute_api.container_run(context, new_container)\\n else:\\n compute_api.container_create(context, new_container)\\n # Set the HTTP Location Header\\n pecan.response.location = link.build_url('containers',\\n new_container.uuid)\\n pecan.response.status = 202\\n return view.format_container(pecan.request.host_url, new_container)\",\n \"def DeployContainer(self, base_name, container_spec):\\n name = base_name + str(len(self.containers[base_name]))\\n container = KubernetesContainer(container_spec=container_spec, name=name)\\n self.containers[base_name].append(container)\\n container.Create()\",\n \"def put_container(self, account, container):\\n \\n pass\",\n \"def createContainer(self, userID, data):\\r\\n while 1:\\r\\n uid = uuid4().hex\\r\\n\\r\\n if uid not in self._pendingContainer:\\r\\n break\\r\\n\\r\\n try:\\r\\n container = self._balancer.createContainer(uid, userID, data)\\r\\n except ContainerProcessError:\\r\\n # TODO: What should we do here?\\r\\n raise InternalError('Container can not be created.')\\r\\n\\r\\n endpoint = EnvironmentEndpoint(self._network, container)\\r\\n self._pendingContainer[uid] = endpoint\\r\\n return endpoint.createNamespace(), container\",\n \"def test_add_container(self):\\n with DockerHost('host', dind=False) as host:\\n # Create a container with --net=none, add a calico interface to\\n # it then check felix programs a route.\\n node = host.create_workload(\\\"node\\\", network=NET_NONE)\\n host.calicoctl(\\\"container add %s 192.168.1.1\\\" % node)\\n\\n # Create the profile, get the endpoint IDs for the containers and\\n # add the profile to the endpoint so felix will pick it up.\\n host.calicoctl(\\\"profile add TEST_GROUP\\\")\\n ep = host.calicoctl(\\\"container %s endpoint-id show\\\" % node)\\n host.calicoctl(\\\"endpoint %s profile set TEST_GROUP\\\" % ep)\\n\\n # Wait for felix to program down the route.\\n check_route = partial(host.execute,\\n \\\"ip route | grep '192\\\\.168\\\\.1\\\\.1'\\\")\\n retry_until_success(check_route, ex_class=CalledProcessError)\",\n \"def ddtest_create_generic_container_w_name(self, name=None):\\n container_resp = self.behaviors.create_container(name, 'generic', [])\\n self._check_container_create_response(container_resp)\\n\\n get_resp = self.container_client.get_container(container_resp.ref)\\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\\n name=name, type='generic')\",\n \"def build_container(client):\\n client.images.build(path=os.path.join(os.path.abspath(\\\"\\\"), \\\"docker\\\"), tag=\\\"scrape_light\\\")\",\n \"def create(self):\\n print('Creating container: {}'.format(self.cfg['name']))\\n create = self.docker_client.create(**self.env)\\n return create['id']\",\n \"def remote_createContainer(self, uid, data):\\r\\n try:\\r\\n nr = self._nrs.pop()\\r\\n except KeyError:\\r\\n raise MaxNumberExceeded('Can not manage any additional container.')\\r\\n\\r\\n container = RCEContainer(self, nr, uid, data)\\r\\n return container.start().addCallback(lambda _: container)\",\n \"def view_createContainer(self, user, tag, data={}):\\r\\n try:\\r\\n validateName(tag)\\r\\n except IllegalName as e:\\r\\n raise InvalidRequest('Container tag is invalid: {0}'.format(e))\\r\\n\\r\\n if tag in user.containers or tag in user.robots:\\r\\n raise InvalidRequest('Tag is already used for a container '\\r\\n 'or robot.')\\r\\n\\r\\n namespace, remote_container = user.realm.createContainer(user.userID,\\r\\n data)\\r\\n container = Container(namespace, remote_container)\\r\\n user.containers[tag] = container\\r\\n container.notifyOnDeath(user.containerDied)\\r\\n\\r\\n m = 'Container {0} successfully created.'.format(tag)\\r\\n d = DeferredList([namespace(), remote_container()],\\r\\n fireOnOneErrback=True, consumeErrors=True)\\r\\n return d.addCallback(lambda _: m)\",\n \"def DeployContainer(self, name, container_spec):\\n raise NotImplementedError()\",\n \"def create(self, imagepath, upgrade=False, local_config=None):\\n logger.info(\\\"Creating container '%s'\\\", self.name)\\n\\n if not os.path.exists(imagepath):\\n raise ContainerError(\\\"'{}' doesn't exist. Please specify a valid image path.\\\".format(imagepath))\\n\\n # create base path a hardlink the iso\\n os.makedirs(self.containerpath)\\n container_imagepath = os.path.join(self.containerpath, os.path.basename(imagepath))\\n try:\\n os.link(imagepath, container_imagepath)\\n except OSError:\\n # might be on a different partition, fall back to symlink then\\n os.symlink(imagepath, container_imagepath)\\n\\n self._mountiso(container_imagepath)\\n\\n if local_config:\\n self.setup_local_config(local_config)\\n\\n # Base rootfs\\n os.makedirs(os.path.join(self.containerpath, \\\"rootfs\\\"))\\n # Tools\\n os.makedirs(os.path.join(self.containerpath, \\\"tools\\\"))\\n # tools and default config from otto\\n self._copy_otto_files()\\n\\n self.container.load_config()\\n\\n if upgrade:\\n self.upgrade()\\n\\n logger.debug(\\\"Creation done\\\")\",\n \"def registry(self):\\n if self._registry is None:\\n print('Creating container registry...')\\n registry_ops = self.registry_client.registries\\n try:\\n registry = registry_ops.get(\\n self.resources.group.name,\\n self.name,\\n )\\n except CloudError:\\n registry_creation = registry_ops.create(\\n self.resources.group.name,\\n self.name,\\n RegistryCreateParameters(\\n location=self.storage.account.location,\\n sku=ContainerRegistrySku(ContainerRegistrySkuName.basic),\\n admin_user_enabled=True,\\n storage_account=StorageAccountParameters(\\n self.storage.account.name,\\n self.storage.key,\\n ),\\n )\\n )\\n registry = registry_creation.result()\\n self._registry = registry\\n print('Got container registry:', registry.name)\\n return self._registry\",\n \"def test_create(set_env, container: Container):\\n # pylint: disable=unused-argument\\n assert container\\n assert isinstance(container, Container)\",\n \"def _newcontainer(self, siginfo):\\n pass\",\n \"def put_container(self, container):\\n if self.onest.create_bucket(container):\\n LOG.debug('put_container, create success. '\\n 'Container: %s.', container)\\n else:\\n # If return false, means exist\\n LOG.info(_LI('put_container, '\\n 'container(%s) exist, just use it.'), container)\",\n \"def ensure_container():\\n return exec_fn(_init_container)\",\n \"def run_container(self,\\n name: str,\\n command: Optional[str] = None,\\n env: Optional[StrDict] = None,\\n volumes: Optional[Dict[str, StrDict]] = None,\\n ports: Optional[Dict[Any, Any]] = None,\\n dns: Optional[List[str]] = None,\\n pid_mode: Optional[str] = None,\\n entrypoint: Optional[str] = None):\\n if volumes is None:\\n volumes = {}\\n if dns is None:\\n dns = []\\n\\n expose = []\\n port_bindings = {}\\n for port in ports.keys():\\n if isinstance(port, tuple):\\n proto = port[1] if len(port) == 2 else \\\"tcp\\\"\\n key = \\\"%d/%s\\\" % (port[0], proto)\\n else:\\n key = port\\n port_bindings[key] = ports[port]\\n expose.append(port)\\n\\n result = self._client.create_container(\\n name, command=command, environment=env,\\n volumes=[volume['bind'] for volume in volumes.values()],\\n ports=expose,\\n entrypoint=entrypoint)\\n\\n container = result[\\\"Id\\\"]\\n result = self._client.start(container, binds=volumes,\\n port_bindings=port_bindings, dns=dns,\\n pid_mode=pid_mode)\\n response = self._client.inspect_container(container)\\n return response\",\n \"def create_lxd_container(public_key=None, name=\\\"test_name\\\"):\\n container = None\\n\\n # Format name so it's valid\\n name = name.replace(\\\"_\\\", \\\"-\\\").replace(\\\".\\\", \\\"\\\")\\n\\n client = get_lxd_client()\\n if not client:\\n raise Exception(\\\"Unable to connect to LXD\\\")\\n\\n test_machine = \\\"test-{}-{}\\\".format(\\n uuid.uuid4().hex[-4:],\\n name,\\n )\\n\\n private_key_path, public_key_path = find_n2vc_ssh_keys()\\n\\n try:\\n # create profile w/cloud-init and juju ssh key\\n if not public_key:\\n public_key = \\\"\\\"\\n with open(public_key_path, \\\"r\\\") as f:\\n public_key = f.readline()\\n\\n client.profiles.create(\\n test_machine,\\n config={\\n 'user.user-data': '#cloud-config\\\\nssh_authorized_keys:\\\\n- {}'.format(public_key)},\\n devices={\\n 'root': {'path': '/', 'pool': 'default', 'type': 'disk'},\\n 'eth0': {\\n 'nictype': 'bridged',\\n 'parent': 'lxdbr0',\\n 'type': 'nic'\\n }\\n }\\n )\\n except Exception as ex:\\n debug(\\\"Error creating lxd profile {}: {}\\\".format(test_machine, ex))\\n raise ex\\n\\n try:\\n # create lxc machine\\n config = {\\n 'name': test_machine,\\n 'source': {\\n 'type': 'image',\\n 'alias': 'xenial',\\n 'mode': 'pull',\\n 'protocol': 'simplestreams',\\n 'server': 'https://cloud-images.ubuntu.com/releases',\\n },\\n 'profiles': [test_machine],\\n }\\n container = client.containers.create(config, wait=True)\\n container.start(wait=True)\\n except Exception as ex:\\n debug(\\\"Error creating lxd container {}: {}\\\".format(test_machine, ex))\\n # This is a test-ending failure.\\n raise ex\\n\\n def wait_for_network(container, timeout=30):\\n \\\"\\\"\\\"Wait for eth0 to have an ipv4 address.\\\"\\\"\\\"\\n starttime = time.time()\\n while(time.time() < starttime + timeout):\\n time.sleep(1)\\n if 'eth0' in container.state().network:\\n addresses = container.state().network['eth0']['addresses']\\n if len(addresses) > 0:\\n if addresses[0]['family'] == 'inet':\\n return addresses[0]\\n return None\\n\\n try:\\n wait_for_network(container)\\n except Exception as ex:\\n debug(\\n \\\"Error waiting for container {} network: {}\\\".format(\\n test_machine,\\n ex,\\n )\\n )\\n\\n try:\\n waitcount = 0\\n while waitcount <= 5:\\n if is_sshd_running(container):\\n break\\n waitcount += 1\\n time.sleep(1)\\n if waitcount >= 5:\\n debug(\\\"couldn't detect sshd running\\\")\\n raise Exception(\\\"Unable to verify container sshd\\\")\\n\\n except Exception as ex:\\n debug(\\n \\\"Error checking sshd status on {}: {}\\\".format(\\n test_machine,\\n ex,\\n )\\n )\\n\\n # HACK: We need to give sshd a chance to bind to the interface,\\n # and pylxd's container.execute seems to be broken and fails and/or\\n # hangs trying to properly check if the service is up.\\n (exit_code, stdout, stderr) = container.execute([\\n 'ping',\\n '-c', '5', # Wait for 5 ECHO_REPLY\\n '8.8.8.8', # Ping Google's public DNS\\n '-W', '15', # Set a 15 second deadline\\n ])\\n if exit_code > 0:\\n # The network failed\\n raise Exception(\\\"Unable to verify container network\\\")\\n\\n return container\",\n \"def start_container(client, work_package, load_saved):\\n package_path = os.path.join(PATH, \\\"work_packages\\\")\\n\\n client.containers.run(image=\\\"scrape_light\\\",\\n environment=[\\\"PACKAGE=\\\"+work_package, \\\"LOAD_FILE=\\\" + load_saved,\\n \\\"USERNAME=patrick.kalmbach@tum.de\\\", \\\"PASSWORD=LA#kYs1#o:`Z\\\"],\\n detach=True, tty=True, stdin_open=True,\\n sysctls={\\\"net.ipv4.conf.all.rp_filter\\\": 2},\\n privileged=True,\\n devices=[\\\"/dev/net/tun\\\"],\\n name=\\\"scrape_\\\" + str(work_package),\\n cap_add=[\\\"NET_ADMIN\\\", \\\"SYS_MODULE\\\"],\\n volumes={package_path: {\\\"bind\\\": \\\"/work_packages\\\"}})\",\n \"def _create_container_registry_secret(self):\\n if not all(key in self.k8s_config for key in [\\\"docker_user\\\", \\\"docker_password\\\"]):\\n return\\n\\n logger.debug('Creating container registry secret')\\n docker_server = self.k8s_config.get('docker_server', 'https://index.docker.io/v1/')\\n docker_user = self.k8s_config.get('docker_user')\\n docker_password = self.k8s_config.get('docker_password')\\n\\n cred_payload = {\\n \\\"auths\\\": {\\n docker_server: {\\n \\\"Username\\\": docker_user,\\n \\\"Password\\\": docker_password\\n }\\n }\\n }\\n\\n data = {\\n \\\".dockerconfigjson\\\": base64.b64encode(\\n json.dumps(cred_payload).encode()\\n ).decode()\\n }\\n\\n secret = client.V1Secret(\\n api_version=\\\"v1\\\",\\n data=data,\\n kind=\\\"Secret\\\",\\n metadata=dict(name=\\\"lithops-regcred\\\", namespace=self.namespace),\\n type=\\\"kubernetes.io/dockerconfigjson\\\",\\n )\\n\\n try:\\n self.core_api.delete_namespaced_secret(\\\"lithops-regcred\\\", self.namespace)\\n except ApiException as e:\\n pass\\n\\n try:\\n self.core_api.create_namespaced_secret(self.namespace, secret)\\n except ApiException as e:\\n if e.status != 409:\\n raise e\",\n \"def createContainer(tag, data={}): #@NoSelf\",\n \"def run(self, container_config: ContainerConfig) -> Container:\",\n \"def create(self, image, command=None, **kwargs):\\n if isinstance(image, Image):\\n image = image.id\\n kwargs['image'] = image\\n kwargs['command'] = command\\n kwargs['version'] = self.client.api._version\\n create_kwargs = _create_container_args(kwargs)\\n resp = self.client.api.create_container(**create_kwargs)\\n return self.get(resp['Id'])\",\n \"def _create_container(self, docker_client: \\\"DockerClient\\\", **kwargs) -> \\\"Container\\\":\\n # Create the container with retries on name conflicts (with an incremented idx)\\n index = 0\\n container = None\\n name = original_name = kwargs.pop(\\\"name\\\")\\n\\n while not container:\\n from docker.errors import APIError\\n\\n try:\\n display_name = repr(name) if name else \\\"with auto-generated name\\\"\\n self.logger.info(f\\\"Creating Docker container {display_name}...\\\")\\n container = docker_client.containers.create(name=name, **kwargs)\\n except APIError as exc:\\n if \\\"Conflict\\\" in str(exc) and \\\"container name\\\" in str(exc):\\n self.logger.info(\\n f\\\"Docker container name {display_name} already exists; \\\"\\n \\\"retrying...\\\"\\n )\\n index += 1\\n name = f\\\"{original_name}-{index}\\\"\\n else:\\n raise\\n\\n self.logger.info(\\n f\\\"Docker container {container.name!r} has status {container.status!r}\\\"\\n )\\n return container\",\n \"def _newcontainer(self, siginfo):\\n self.logger.log('creating a new %s with siginfo %r' % (self.cname, (siginfo, )))\\n if self.ourcontainer:\\n self.logger.log('freeing previously loaded %s' % (self.cname))\\n self.announcequeue.append(self.ourcontainer)\\n self.ourcontainer.save()\\n self.ourcontainer.complete = True\\n self.session.add(self.ourcontainer)\\n\\n self.ourcontainer = self.container(self.config.owner, self.config, siginfo=siginfo)\\n self.ourcontainer.create(int(self.config.container_manager.maxcapacity))\\n self.ourcontainer.save()\\n self.logger.log(\\\"New %s's filename: %s\\\" % (self.cname, self.ourcontainer.filename))\",\n \"def DeployContainerService(self, name, container_spec):\\n service = KubernetesContainerService(container_spec, name)\\n self.services[name] = service\\n service.Create()\",\n \"def container(self, image: str, **kwargs) -> container.Container:\\n raise NotImplementedError\",\n \"def start_container(self):\\n logger = logging.getLogger(self.dkr_name)\\n logger.info(\\\"Starting up container\\\")\\n\\n try:\\n svc = self.docker_client().containers.get(self.dkr_name)\\n except Exception:\\n svc = self.docker_client().containers.run(image=self.dkr_image,\\n name=self.dkr_name,\\n command=self.dkr_command,\\n ports=self.dkr_ports,\\n links=self.dkr_links,\\n environment=self.dkr_env,\\n detach=True,\\n remove=self.dkr_remove)\\n\\n while svc.status != \\\"running\\\":\\n svc.reload()\\n sleep(1)\\n\\n self.dkr_container = svc\",\n \"def create(self, resource):\\r\\n self._load_resource(resource)\\r\\n blob_folder = self._blob_folder()\\r\\n if is_folder(blob_folder):\\r\\n logger.warning(self._context(\\\"Container already exists\\\"))\\r\\n else:\\r\\n # create new container\\r\\n logger.info(self._context(\\\"Creating container\\\"))\\r\\n create_folder(blob_folder)\\r\\n\\r\\n self.disconnect()\\r\\n return is_folder(blob_folder)\",\n \"def factory(container, name, factory):\",\n \"def ddtest_create_rsa_container_w_name(self, name=None):\\n secret_urls = self.secret_behaviors.create_n_secrets(3)\\n container_resp = self.behaviors.create_rsa_container(\\n name, secret_urls[0], secret_urls[1], secret_urls[2])\\n self._check_container_create_response(container_resp)\\n\\n get_resp = self.container_client.get_container(container_resp.ref)\\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\\n name=name, type='rsa')\",\n \"def request_new_instance( self ):\\n\\n request_id = self.az_commands.invoke( \\\"add\\\",\\n background=True,\\n bg_callback=self.process_new_instance,\\n name=\\\"{0}-{1}\\\".format( self.instance_name, self.next_host_id ),\\n registrypassword=self.docker_auth,\\n image=self.instance_type,\\n query=\\\"'{id:id, name:name, ip:ipAddress.ip, type:containers[0].image, status:provisioningState}'\\\")[0]\\n\\n # create a new host object\\n hobj = hostObject.HostObject(self.next_host_id, hostObject.HostObject.TYPE_CONTAINER)\\n\\n self.active_request[ request_id ] = hobj\\n self.instances.append( hobj )\\n\\n self.next_host_id += 1\",\n \"def create_node(self, **kwargs):\\n default = \\\"ubuntu.precise\\\"\\n template = {\\\"name\\\":\\\"ubuntu\\\", \\\"args\\\":[]}\\n if 'image' not in kwargs:\\n kwargs['image'] = default\\n \\n for image in self.list_images():\\n if image.name == kwargs['image']:\\n template = {\\\"name\\\":image.extra[\\\"template_name\\\"],\\n \\\"args\\\":image.extra[\\\"template_args\\\"]\\n }\\n \\n name = kwargs['name']\\n container = {\\n \\\"cgroups\\\": [],\\n \\\"name\\\": name,\\n \\\"conf\\\": [],\\n \\\"template\\\": template\\n }\\n \\n self.connection.request(action=\\\"/v1/containers\\\", method=\\\"POST\\\", data=json.dumps(container))\\n self.connection.request(action=\\\"/v1/containers/%s/actions/start\\\" % name, method=\\\"POST\\\")\\n return self.get_node(name)\",\n \"def _constructInstance(self, container, id, *args, **kw):\\n file, title = None, ''\\n id = container.manage_addProduct['OFSP'].manage_addImage(id, file, title)\\n return container.get(id, None)\",\n \"def docker_container():\\n if SETUP_SPLASH:\\n dm = DockerManager()\\n dm.start_container()\\n\\n try:\\n requests.post('{}/_gc'.format(SPLASH_URL))\\n except requests.exceptions.RequestException:\\n pass\\n\\n yield\",\n \"def create_and_init_container( # noqa pylint: disable=too-many-arguments\\n self,\\n image: docker.models.images.Image,\\n container_name: str,\\n target_adapter: Type['BaseTargetAdapter'],\\n source_adapter: str,\\n network: docker.models.networks.Network,\\n replica_volume: docker.models.volumes.Volume,\\n envars: dict\\n ) -> docker.models.containers.Container:\\n\\n logger.info(\\n f\\\"Creating stopped container {container_name}...\\\")\\n\\n port = target_adapter.DOCKER_TARGET_PORT\\n hostname = target_adapter.credentials.host\\n protocol = 'tcp'\\n port_dict = {f\\\"{str(port)}/{protocol}\\\": port}\\n\\n self.remove_container(container_name)\\n\\n container = self.client.containers.create(\\n image.tags[0],\\n target_adapter.DOCKER_START_COMMAND,\\n network=network.name,\\n name=container_name,\\n hostname=hostname,\\n ports=port_dict,\\n environment=envars,\\n labels=dict(\\n snowshu_replica='true',\\n target_adapter=target_adapter.CLASSNAME,\\n source_adapter=source_adapter),\\n detach=True,\\n volumes={replica_volume.name: {\\n 'bind': f'{DOCKER_REPLICA_MOUNT_FOLDER}'\\n }},\\n working_dir=DOCKER_WORKING_DIR\\n )\\n logger.info(\\n f\\\"Created stopped container {container.name}, connecting it to bridge network...\\\")\\n self._connect_to_bridge_network(container)\\n logger.info(\\n f'Connected. Starting created container {container.name}...')\\n try:\\n container.start()\\n except docker.errors.APIError as error:\\n if 'port is already allocated' in error.explanation:\\n logger.exception('One of the ports used by snowshu_target is '\\n 'already allocated, stop extra containers and rerun')\\n raise\\n logger.info(\\n f'Container {container.name} started, running initial setup...')\\n self._run_container_setup(container, target_adapter)\\n logger.info(f'Container {container.name} fully initialized.')\\n\\n return container\",\n \"def test_rackspace_uploader_creates_container(self, mock, mock2):\\r\\n with patch('pybossa.uploader.rackspace.pyrax.cloudfiles') as mycf:\\r\\n mycf.get_container.side_effect = NoSuchContainer\\r\\n mycf.create_container.return_value = True\\r\\n mycf.make_container_public.return_value = True\\r\\n u = RackspaceUploader()\\r\\n res = u.init_app(self.flask_app)\\r\\n err_msg = \\\"Init app should return the container.\\\"\\r\\n assert res is True, err_msg\",\n \"def create_container(cls, values):\\n dbdriver = get_instance()\\n return dbdriver.create_container(values)\",\n \"def start(self) -> None:\\r\\n # --ulimit nofile=<soft limit>:<hard limit> set the limit for open files\\r\\n docker_run_command = ('docker run --ulimit nofile=65535:65535 -td -p %d:8545 -p %d:30303 --rm --name %s %s' %\\r\\n (self.rpc_port, self.ethereum_network_port, self.name, IMAGE))\\r\\n sleep(0.6)\\r\\n result = self.ip.exec_command(docker_run_command)\\r\\n if result:\\r\\n if result.startswith('docker: Error'):\\r\\n print(result)\\r\\n print(self.ip)\\r\\n raise RuntimeError('An error occurs while starting docker container. Container maybe already exists')\\r\\n print('container of node %s of blockchain %s at %s:%s started' % (self.node_index, self.blockchain_id,\\r\\n self.ip.address, self.rpc_port))\\r\\n new_account_command = 'docker exec -t %s geth --datadir abc account new --password passfile' % self.name\\r\\n sleep(0.1)\\r\\n account = self.ip.exec_command(new_account_command).split()[-1][1:-1]\\r\\n sleep(0.3)\\r\\n if len(account) == 40: # check if the account is valid\\r\\n self.accounts.append(account)\\r\\n else:\\r\\n print('invalid account')\",\n \"def _update_container(self):\\n client = docker.from_env()\\n self.container = client.containers.get(self.session.container_id)\",\n \"def ddtest_create_container_w_secret_name(self, name=None):\\n # create a container with a particular secret name\\n responses = self.behaviors.create_container_with_secret(\\n name='name', secret_name=name)\\n secret_resp, container_resp = responses\\n self._check_container_create_response(container_resp)\\n\\n # verify the container exists with the expected data\\n get_resp = self.container_client.get_container(container_resp.ref)\\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\\n name='name', type='generic',\\n num_secrets=1)\\n\\n # verify the secret's name is returned correctly\\n secret_ref = get_resp.entity.secret_refs[0]\\n self.assertEqual(secret_ref.name, name)\",\n \"def _launch_local_catalog():\\n open_config = api._config()\\n command = [\\\"docker\\\", \\\"run\\\", \\\"--rm\\\"]\\n env = dict(REGISTRY_URL=\\\"http://localhost:5000\\\",\\n S3_PROXY_URL=\\\"http://localhost:5002\\\",\\n ALWAYS_REQUIRE_AUTH=\\\"false\\\",\\n CATALOG_MODE=\\\"LOCAL\\\",\\n SSO_AUTH=\\\"DISABLED\\\",\\n PASSWORD_AUTH=\\\"ENABLED\\\",\\n API_GATEWAY=open_config[\\\"apiGatewayEndpoint\\\"],\\n BINARY_API_GATEWAY=open_config[\\\"binaryApiGatewayEndpoint\\\"])\\n for var in [f\\\"{key}={value}\\\" for key, value in env.items()]:\\n command += [\\\"-e\\\", var]\\n command += [\\\"-p\\\", \\\"3000:80\\\", \\\"quiltdata/catalog\\\"]\\n subprocess.Popen(command)\",\n \"def _create(self, variables):\\n required_vars = ['container']\\n variables_dict = self._get_vars(variables, required=required_vars)\\n\\n container_name = variables_dict.pop('container')\\n container_data = self._create_container(container_name=container_name)\\n\\n if not container_data:\\n container_data = self.swift.head_container(container_name)\\n\\n return self._facts(facts=[container_data])\",\n \"def ddtest_create_generic_container_w_empty_or_null_name(self, name=None):\\n if name is None:\\n self._skip_on_issue('launchpad', '1354767')\\n\\n container_resp = self.behaviors.create_container(name, 'generic', [])\\n self._check_container_create_response(container_resp)\\n\\n get_resp = self.container_client.get_container(container_resp.ref)\\n self._check_container_get_resp(get_resp, ref=container_resp.ref,\\n name=container_resp.id, type='generic')\",\n \"def setup(self):\\n\\n exists = [i for i in self.client.images() if self.image in i['RepoTags']]\\n\\n # Only pull the image if we don't have it\\n if not exists or self.pull:\\n self.client.pull(self.image)\\n self.logger.debug(\\\"Pulled {}\\\".format(self.image))\\n\\n self.container = self.client.create_container(\\n image=self.image,\\n host_config=self.host_config,\\n name=self.name,\\n command=self.command,\\n environment=self.environment\\n )\\n self.logger.debug(\\\"Created container {}\\\".format(self.container['Id']))\",\n \"def create(cls, name, container_object, enable=True, optional_attributes={}):\\n assert type(name) == str\\n assert container_object.__class__.__name__ == 'ADContainer'\\n return container_object.create_computer(name=name,enable=enable,optional_attributes=optional_attributes)\",\n \"def start(self, container: Container):\",\n \"def create_metasploit_container(self, instance_id):\\n all_containers_documents = self.database.get_docker_documents(amazon_resource_id=instance_id, type=self.type)\\n\\n new_container = ContainerOperations(\\n docker_server_id=instance_id\\n ).run_container_with_msfrpcd_metasploit(containers_documents=all_containers_documents)\\n\\n container_response = new_container_response(container=new_container)\\n\\n self.database.add_docker_document(\\n amazon_resource_id=instance_id, docker_document_type=self.type, new_docker_document=container_response\\n )\\n\\n return container_response\",\n \"def test001_create_containers(self):\\n self.log('%s STARTED' % self._testID)\\n\\n self.log('Create a two container on that node, should succeed.')\\n self.cont1_name = self.random_string()\\n self.containers = {self.cont1_name: {'hostname': self.cont1_name,\\n 'flist': self.cont_flist,\\n 'storage': self.cont_storage}}\\n\\n self.cont2_name = self.random_string()\\n self.containers.update({self.cont2_name: {'hostname': self.cont2_name,\\n 'flist': self.cont_flist,\\n 'storage': self.cont_storage}})\\n\\n res = self.create_container(containers=self.containers, temp_actions=self.temp_actions)\\n self.assertEqual(type(res), type(dict()))\\n self.wait_for_service_action_status(self.cont1_name, res[self.cont1_name]['install'])\\n self.wait_for_service_action_status(self.cont2_name, res[self.cont2_name]['install'])\\n\\n self.log('Check that the container have been created.')\\n conts = self.zos_client.container.list()\\n self.assertTrue([c for c in conts.values() if c['container']['arguments']['name'] == self.cont1_name])\\n self.assertTrue([c for c in conts.values() if c['container']['arguments']['name'] == self.cont2_name])\\n cont1 = [c for c in conts.values() if c['container']['arguments']['name'] == self.cont1_name][0]\\n self.assertTrue(cont1['container']['arguments']['storage'], self.cont_storage)\\n self.assertTrue(cont1['container']['arguments']['root'], self.cont_flist)\\n self.assertTrue(cont1['container']['arguments']['hostname'], self.cont_flist)\\n\\n self.log('%s ENDED' % self._testID)\",\n \"def __create__container(self):\\n self.__used_containers.append(contenedor.Arena(self.__blocks_size))\",\n \"def _put_container_on_host(self, container_name):\\n with hide(\\\"output\\\", \\\"warnings\\\", \\\"running\\\"):\\n # first see if container is already present on host\\n host_result = self._execute_root(\\n \\\"docker images -q {cn}\\\".format(cn=container_name))\\n if len(host_result.stdout) > 0:\\n print(\\\"Found %s on host\\\" % container_name)\\n return True\\n # now try to pull from Docker Hub\\n hub_result = self._execute_root(\\\"docker pull {cn}\\\".format(cn=container_name),\\n warn_only=True)\\n if hub_result.return_code == 0:\\n print(\\\"Found %s in Docker hub\\\" % container_name)\\n return True\\n\\n # assume container_name refers to a local container and\\n # copy it to host\\n local_result = local(\\n \\\"docker images -q {cn}\\\".format(cn=container_name))\\n\\n if len(local_result.stdout) > 0:\\n saved_fname = container_name.replace(\\\"/\\\", \\\"_\\\")\\n subprocess.call(\\\"docker save -o /tmp/{fn}.tar {cn}\\\".format(\\n fn=saved_fname,\\n cn=container_name))\\n tar_loc = \\\"/tmp/{fn}.tar\\\".format(fn=saved_fname)\\n self._execute_put(tar_loc, tar_loc)\\n self._execute_root(\\\"docker load -i {loc}\\\".format(loc=tar_loc))\\n # self._execute_root(\\\"docker tag {image_id} {cn}\\\".format(\\n # image_id=image_id, cn=cn))\\n # now check to make sure we can access it\\n host_result = self._execute_root(\\n \\\"docker images -q {cn}\\\".format(cn=container_name))\\n if len(host_result.stdout) > 0:\\n print(\\\"Successfuly copied %s to host\\\" % container_name)\\n return True\\n else:\\n warn(\\n \\\"Problem copying container %s to host\\\" %\\n container_name)\\n return False\\n\\n # out of options\\n warn(\\\"Could not find %s, please try with a valid \\\"\\n \\\"container docker image\\\")\\n return False\",\n \"def creating_container(self, service):\\n self.sync_code(service=service)\\n externals = [v.external for v in service.options['volumes']]\\n for v in self.get_hotcode_volumes(service):\\n if v.external not in externals:\\n service.options['volumes'].append(v)\",\n \"def start(self):\\n if self.session.status == Session.SessionStatus.RUNNING:\\n return\\n self._make_fifo()\\n client = docker.from_env()\\n\\n volumes = {}\\n if self.session.notebook:\\n volumes.update(get_accessible_datasets_mount_dict(self.session.notebook))\\n volumes.update({self.fifo_path: {\\\"bind\\\": f\\\"/{self.fifo_name}\\\"}})\\n\\n self.container = client.containers.run(\\n \\\"m.docker-registry.ir/python:3.8-slim-buster\\\",\\n [\\\"sh\\\", \\\"-c\\\", f\\\"python -i -u <>/{self.fifo_name}\\\"],\\n stdin_open=True,\\n detach=True,\\n volumes=volumes\\n )\\n self.session.container_id = str(self.container.id)\\n self.session.status = Session.SessionStatus.RUNNING\\n self.session.run_counter = 1\\n self.session.save()\",\n \"def _process_createContainer(self, data):\\r\\n try:\\r\\n self._avatar.createContainer(data['containerTag'],\\r\\n data.get('containerData', {}))\\r\\n except KeyError as e:\\r\\n raise InvalidRequest(\\\"Can not process 'CreateContainer' request. \\\"\\r\\n 'Missing key: {0}'.format(e))\",\n \"def create_container(self, image=None, tag=None):\\n if image is not None:\\n image_name = image.tags[0]\\n elif tag is not None:\\n image_name = self.build_image_name(tag)\\n else:\\n raise ValueError('No image or tag to run')\\n\\n return self.client.containers.create(image_name,\\n privileged=True,\\n detach=True,\\n name='acrobat',\\n volumes={'/dev/acrobat/fc': {'bind': '/dev/acrobat/fc', 'mode': 'rw'},\\n '/dev/acrobat/radio': {'bind': '/dev/acrobat/radio', 'mode': 'rw'},\\n '/media/acrobat/logs': {'bind': '/logs', 'mode': 'rw'}})\",\n \"def machine_new(node=\\\"dev\\\", driver='virtualbox'):\\n machine = Dockerizing(driver)\\n\\n # Check that the requested node does not already exist\\n if node in machine.list():\\n print(colors.warn | \\\"Failed:\\\", colors.bold |\\n \\\"Machine '%s' Already exists\\\" % node)\\n return\\n machine.create(node)\\n\\n # Create the machine\\n _logger.info(\\\"Preparing machine\\\", node)\\n print(machine.create(node))\\n _logger.info(colors.green | \\\"Created!\\\\n\\\\n\\\")\",\n \"def DeployContainerService(self, name, container_spec, num_containers):\\n raise NotImplementedError()\",\n \"def create(self, name, image, fetch_image=False, network=None, volumes={},\\n **kwargs):\\n create_kwargs = {\\n 'detach': True,\\n }\\n\\n # Convert network & volume models to IDs\\n network = self._network_for_container(network, kwargs)\\n if network is not None:\\n network_id, network = (\\n self._network_helper._get_id_and_model(network))\\n create_kwargs['network'] = network_id\\n\\n if volumes:\\n create_kwargs['volumes'] = self._volumes_for_container(volumes)\\n\\n create_kwargs.update(kwargs)\\n\\n if fetch_image:\\n self._image_helper.fetch(image)\\n\\n container = super().create(name, image, **create_kwargs)\\n\\n if network is not None:\\n self._connect_container_network(container, network, aliases=[name])\\n\\n return container\",\n \"def create(self, execution_script, arguments, more_than_one):\\n container_create_time = timer()\\n\\n client = docker.from_env(timeout=60)\\n\\n mount = {\\n self.directory: {\\n 'bind': self.directory,\\n 'mode': 'rw'\\n }\\n }\\n\\n # Only pass container name to testcases with greater than one container.\\n # (Doing otherwise breaks compilation)\\n container_name_argument = ['--container_name', self.name] if more_than_one else []\\n # A server container does not run student code, but instead hosts\\n # a service (i.e. a database.)\\n\\n try:\\n if self.is_server:\\n self.container = client.containers.create(\\n self.image,\\n stdin_open=True,\\n tty=True,\\n network='none',\\n volumes=mount,\\n working_dir=self.directory,\\n name=self.full_name\\n )\\n else:\\n container_ulimits = rlimit_utils.build_ulimit_argument(\\n self.container_rlimits,\\n self.image\\n )\\n command = [execution_script, ] + arguments + container_name_argument\\n self.container = client.containers.create(\\n self.image,\\n command=command,\\n ulimits=container_ulimits,\\n stdin_open=True,\\n tty=True,\\n network='none',\\n user=self.container_user_argument,\\n volumes=mount,\\n working_dir=self.directory,\\n hostname=self.name,\\n name=self.full_name\\n )\\n except docker.errors.ImageNotFound:\\n self.log_function(f'ERROR: The image {self.image} is not available on this worker')\\n client.close()\\n raise\\n except Exception:\\n self.log_function(f'ERROR: could not create container {self.full_name}')\\n client.close()\\n raise\\n\\n self.log_container(\\n 'CREATED',\\n self.full_name,\\n self.container.short_id,\\n timer() - container_create_time\\n )\\n client.close()\",\n \"def __create_cont(self, path, filesystem, cont_stat, component_number):\\n try:\\n self.logger.debug('Create container interface called')\\n status_obj = Status()\\n cont_id = \\\"container\\\"\\n #cont_id = get_container_id()\\n tmp_path = '%s/%s/%s/%s/%s' % (self.__fs_base, \\\\\\n filesystem, TMPDIR, cont_id,component_number)\\n self.asyn_helper.call(\\\"create_container\\\", \\\\\\n tmp_path, path, cont_stat, status_obj)\\n return status_obj\\n except Exception as err:\\n self.logger.error(('create_container for %(con_dir)s failed ',\\n 'close failure: %(exc)s : %(stack)s'),\\n {'con_dir' : path, \\n 'exc': err, 'stack': ''.join(traceback.format_stack())})\\n raise err\",\n \"def launch_container(self, service_info):\\n user, instance = _get_user_and_instance(\\n self.girder_client, service_info['instanceId'])\\n tale = self.girder_client.get(f\\\"/tale/{service_info['taleId']}\\\")\\n\\n self.job_manager.updateProgress(\\n message='Starting container', total=LAUNCH_CONTAINER_STEP_TOTAL,\\n current=1, forceFlush=True)\\n\\n print(\\\"Launching container for a Tale...\\\")\\n if 'imageInfo' not in tale:\\n\\n # Wait for image to be built\\n tic = time.time()\\n timeout = 180.0\\n time_interval = 5\\n\\n while time.time() - tic < timeout:\\n tale = self.girder_client.get('/tale/{taleId}'.format(**instance))\\n if 'imageInfo' in tale and 'digest' in tale['imageInfo']:\\n break\\n msg = f\\\"Waiting for image build to complete. ({time_interval}s)\\\"\\n logging.info(msg)\\n print(msg)\\n time.sleep(5)\\n\\n container_config = _get_container_config(self.girder_client, tale)\\n service, attrs = _launch_container(service_info, container_config)\\n print(\\n f\\\"Started a container using volume: {service_info['volumeName']} \\\"\\n f\\\"on node: {service_info['nodeId']}\\\"\\n )\\n\\n # wait until task is started\\n tic = time.time()\\n timeout = 300.0\\n started = False\\n\\n print(\\\"Waiting for the environment to be accessible...\\\")\\n while time.time() - tic < timeout:\\n try:\\n status = service.tasks()[0]['Status']\\n\\n if status['State'] in {\\\"failed\\\", \\\"rejected\\\"}:\\n raise ValueError(\\\"Failed to start environment: %s\\\" % status['Err'])\\n elif status['State'] == \\\"running\\\":\\n started = True\\n break\\n\\n except IndexError:\\n started = False\\n\\n time.sleep(0.2)\\n\\n if not started:\\n raise ValueError(\\\"Tale did not start before timeout exceeded\\\")\\n\\n print(\\\"Environment is up and running.\\\")\\n self.job_manager.updateProgress(\\n message='Container started', total=LAUNCH_CONTAINER_STEP_TOTAL,\\n current=LAUNCH_CONTAINER_STEP_TOTAL, forceFlush=True)\\n\\n service_info.update(attrs)\\n service_info['name'] = service.name\\n return service_info\",\n \"def createContainer(self, user, dataSet):\\n\\n dmSession = Session()\\n session = dmSession.createSession(user, dataSet)\\n\\n container = {\\n '_id': objectid.ObjectId(),\\n 'ownerId': user['_id'],\\n 'status': 'Starting',\\n 'sessionId': session['_id']\\n }\\n\\n self.setUserAccess(container, user = user, level = AccessType.ADMIN)\\n\\n container = self.save(container)\\n\\n self.startContainer(user, container)\\n logger.info(\\\"Container \\\" + str(container['_id']) + \\\" started\\\")\\n\\n return container\",\n \"def get_container(self, name):\\r\\n try:\\r\\n return self.cf.get_container(name)\\r\\n except pyrax.exceptions.NoSuchContainer:\\r\\n c = self.cf.create_container(name)\\r\\n self.cf.make_container_public(name)\\r\\n return c\",\n \"def containers_init(self):\\n\\n def test_container(name, state, status):\\n \\\"\\\"\\\"Creates test container. \\\"\\\"\\\"\\n return {\\n 'Image': \\\"alpine:3.7\\\",\\n 'Command': \\\"/bin/sleep 999\\\",\\n 'Labels': {'out': ''},\\n 'State': state,\\n 'Created': 1524205394,\\n 'Status': status,\\n 'Names': [\\\"/\\\" + name]\\n }\\n\\n state_created = 'created'\\n state_running = 'running'\\n\\n status_created = 'Created'\\n status_up = 'Up 15 minutes'\\n\\n self.containers_list = [\\n test_container(self.container_to_run,\\n state_created, status_created),\\n test_container(self.container_running,\\n state_running, status_up),\\n test_container(self.container_to_remove,\\n state_created, status_created),\\n ]\\n\\n CLIENT.containers_list.extend(self.containers_list)\",\n \"def _create_container(self, finding):\\n\\n container_dict = {}\\n container_dict['name'] = finding['Title']\\n container_dict['source_data_identifier'] = finding['Id']\\n container_dict['description'] = finding['Description']\\n\\n container_creation_status, container_creation_msg, container_id = self.save_container(container=container_dict)\\n\\n if phantom.is_fail(container_creation_status):\\n self.debug_print(container_creation_msg)\\n self.save_progress('Error while creating container for finding {finding_id}. '\\n '{error_message}'.format(finding_id=finding['Id'],\\n error_message=container_creation_msg))\\n return None\\n\\n return container_id\",\n \"def test_create_container_privilege(self):\\n pass\",\n \"def create_registry_secret(secret_name, docker_registry, docker_username, docker_password, namespace):\\n add_registry_completed = run([\\\"kubectl\\\", \\\"create\\\", \\\"secret\\\", \\\"docker-registry\\\", secret_name,\\n \\\"--docker-server=%s\\\" % docker_registry,\\n \\\"--docker-username=%s\\\" % docker_username,\\n \\\"--docker-password=%s\\\" % docker_password,\\n \\\"--namespace=%s\\\" % namespace],\\n stdout=PIPE,\\n stderr=PIPE)\\n if add_registry_completed.returncode == 0:\\n value = add_registry_completed.stdout.decode('utf-8').strip()\\n else:\\n value = add_registry_completed.stderr.decode('utf-8').strip()\\n\\n return {'returncode': add_registry_completed.returncode, 'value': value}\",\n \"def _restart(self, docker_image_name):\\n if self.docker_repo:\\n docker_image_name = '%s/%s' % (self.docker_repo,\\n docker_image_name)\\n\\n docker_container_name = '%s_%s' % (self.docker_image_name_prefix,\\n self.scope)\\n\\n mounts = [\\n DockerMount('/dev/log', '/dev/log', type='bind'),\\n DockerMount(self.paths.sandbox_pipe_dir,\\n self.paths.host_pipe_dir,\\n type='bind'),\\n DockerMount(self.paths.sandbox_storlet_base_dir,\\n self.paths.host_storlet_base_dir,\\n type='bind'),\\n DockerMount(self.paths.sandbox_storlet_native_lib_dir,\\n self.paths.host_storlet_native_lib_dir,\\n type='bind', read_only=True),\\n DockerMount(self.paths.sandbox_storlet_native_bin_dir,\\n self.paths.host_storlet_native_bin_dir,\\n type='bind', read_only=True)\\n ]\\n\\n try:\\n client = docker.from_env()\\n # Stop the existing storlet container\\n try:\\n scontainer = client.containers.get(docker_container_name)\\n except docker.errors.NotFound:\\n # The container is not yet created\\n pass\\n else:\\n scontainer.stop(timeout=self.sandbox_stop_timeout)\\n\\n # Check whether a new container can be started\\n if self.max_containers_per_node > 0:\\n all_scontainers = client.containers.list(\\n filters={'label': 'managed_by=storlets'})\\n if len(all_scontainers) >= self.max_containers_per_node:\\n raise StorletRuntimeException(\\n \\\"Cannot start a container because of limit\\\")\\n\\n # Start the new one\\n client.containers.run(\\n docker_image_name, detach=True, name=docker_container_name,\\n network_disabled=True, mounts=mounts, user='swift',\\n auto_remove=True, stop_signal='SIGHUP',\\n labels={'managed_by': 'storlets'})\\n except docker.errors.ImageNotFound:\\n msg = \\\"Image %s is not found\\\" % docker_image_name\\n raise StorletRuntimeException(msg)\\n except docker.errors.APIError:\\n self.logger.exception(\\\"Failed to manage docker containers\\\")\\n raise StorletRuntimeException(\\\"Docker runtime error\\\")\",\n \"def create(self, name, containerFormat, diskFormat, isPublic, pathFile):\\n if isPublic:\\n isPublic = \\\"public\\\"\\n else:\\n isPublic = \\\"private\\\"\\n\\n image = self.client.images.create(name=name, container_format=containerFormat, disk_format=diskFormat, is_public=isPublic)\\n # Thread ?\\n self.client.images.upload(image.id, open(pathFile, 'rb'))\\n while image.status == \\\"queued\\\":\\n image = self.find(image_id=image.id)\\n time.sleep(1)\\n return self.find(image_id=image.id)\",\n \"def GenerateContainer(ctx, \\n container_name=None, \\n container_iname=None,\\n base_interfaces=()\\n ):\\n # create container\\n container_name = container_name or \\\\\\n \\\"%sContainer\\\" % (ctx.domain_model.__name__)\\n \\n # allow passing in dotted python path\\n if isinstance(ctx.container_module, (str, unicode)):\\n ctx.container_module = resolve(ctx.container_module)\\n \\n # if not present use the domain class's module\\n elif ctx.container_module is None:\\n ctx.container_module = resolve(ctx.domain_model.__module__)\\n \\n # sanity check we have a module for the container\\n assert isinstance(ctx.container_module, types.ModuleType), \\\"Invalid Container\\\"\\n \\n # logging variables\\n msg = (ctx.domain_model.__name__, \\n ctx.container_module.__name__, container_name)\\n \\n # if we already have a container class, exit \\n if getattr(ctx.container_module, container_name, None):\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: found container %s.%s, skipping\\\" % msg)\\n ctx.container_class = getattr(ctx.container_module, container_name)\\n return\\n \\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: generated container %s.%s\\\" % msg)\\n \\n # if we already have a container class, exit\\n container_class = type(container_name,\\n (AlchemistContainer,),\\n dict(_class=ctx.domain_model,\\n __module__=ctx.container_module.__name__)\\n )\\n setattr(ctx.container_module, container_name, container_class)\\n \\n # save container class on catalyst context\\n ctx.container_class = container_class\\n \\n # interface for container\\n container_iname = container_iname or \\\"I%s\\\" % container_name\\n \\n # if the interface module is none, then use the nearest one to the domain class\\n if ctx.interface_module is None:\\n ctx.interface_module = _get_interface_module_for(ctx)\\n\\n msg = (ctx.domain_model.__name__,\\n ctx.container_module.__name__, container_iname)\\n \\n # if we already have a container interface class, skip creation\\n container_interface = getattr(ctx.interface_module, container_iname, None)\\n if container_interface is not None:\\n assert issubclass(container_interface, IAlchemistContainer)\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: skipping container interface %s.%s for\\\" % msg)\\n else:\\n if ctx.echo:\\n ctx.logger.debug(\\\"%s: generated container interface %s.%s\\\" % msg)\\n # ensure that our base interfaces include alchemist container \\n if base_interfaces:\\n assert isinstance(base_interfaces, tuple)\\n found = False\\n for bi in base_interfaces:\\n found = issubclass(bi, IAlchemistContainer)\\n if found: break\\n if not found:\\n base_interfaces = base_interfaces + (IAlchemistContainer,)\\n else:\\n base_interfaces = (IAlchemistContainer,)\\n \\n # create interface\\n container_interface = interface.interface.InterfaceClass(\\n container_iname,\\n bases=base_interfaces,\\n __module__=ctx.interface_module.__name__\\n )\\n # store container interface for catalyst\\n ctx.container_interface = container_interface\\n setattr(ctx.interface_module, container_iname, container_interface)\\n \\n # setup security\\n for n,d in container_interface.namesAndDescriptions(1):\\n protectName(container_class, n, \\\"zope.Public\\\")\\n \\n if not container_interface.implementedBy(container_class):\\n interface.classImplements(container_class, container_interface)\\n ctx.container_interface = container_interface\",\n \"def get_container_by_name(self, container_name, is_source):\\n if container_name not in self.containers:\\n self.containers[container_name] = self.create_container(container_name, is_source)\\n return self.containers[container_name]\",\n \"def test_container_cycle(self):\\n # Before Create\\n print(\\\"Create\\\")\\n rep = post(self.url + \\\"/search\\\", data={'name': name})\\n self.errorCatch(rep)\\n\\n # Create\\n rep = post(self.url + \\\"/create\\\", data={\\n 'image': default_image,\\n 'homepath': \\\"/nashome/guest/test\\\",\\n 'naspath': \\\"/home/nas/test\\\",\\n 'command': \\\"tail -f /dev/null\\\",\\n 'name': name})\\n self.checkRunning()\\n\\n # Double create\\n rep = post(self.url + \\\"/create\\\", data={\\n 'image': default_image,\\n 'homepath': \\\"/nashome/guest/test\\\",\\n 'naspath': \\\"/home/nas/test\\\",\\n 'command': \\\"tail -f /dev/null\\\",\\n 'name': name})\\n self.errorCatch(rep)\\n\\n # Check by api\\n con = client.containers.get(name)\\n self.assertIn(\\\"tmp0\\\", con.exec_run(\\\"ls /home/nas\\\").output.decode())\\n self.assertIn(\\\"tmp1\\\", con.exec_run(\\\"ls /home/ubuntu\\\").output.decode())\\n self.assertEqual(con.status, \\\"running\\\")\\n\\n # Stop\\n con.exec_run(\\\"touch /opt/tmp2\\\").output.decode()\\n print(\\\"Stop\\\")\\n rep = post(self.url + \\\"/stop\\\", data={'name': name})\\n self.checkOK(rep)\\n\\n # check stop\\n rep = post(self.url + \\\"/search\\\", data={'name': name})\\n self.checkOK(rep)\\n rep = rep.json()\\n self.assertIsInstance(rep[\\\"data\\\"], dict)\\n self.assertEqual(rep['data']['status'], \\\"exited\\\")\\n\\n # start\\n print(\\\"Resume\\\")\\n rep = post(self.url + \\\"/start\\\", data={'name': name})\\n self.checkOK(rep)\\n self.checkRunning()\\n con = client.containers.get(name)\\n self.assertIn(\\\"tmp2\\\", con.exec_run(\\\"ls /opt\\\").output.decode())\\n\\n # change pw\\n print(\\\"Change Password\\\")\\n con.exec_run(\\\"adduser ubuntu\\\")\\n rep = post(self.url + \\\"/passwd\\\", data={'name': name,\\n 'pw': \\\"tmpPW\\\"})\\n self.checkOK(rep)\\n self.assertIn(\\\"tmpPW\\\", con.exec_run(\\\"cat /etc/shadow\\\").output.decode())\\n\\n # commit\\n print(\\\"Commit\\\")\\n rep = post(self.url + \\\"/commit\\\", data={'name': name,\\n 'newname': name})\\n self.checkOK(rep)\\n\\n # search image\\n rep = post(self.url + \\\"/search/image\\\", data={'name': name})\\n rep = rep.json()\\n self.assertIsInstance(rep['data'], dict)\\n\\n # delete\\n print(\\\"Delete\\\")\\n rep = post(self.url + \\\"/delete\\\", data={'name': name})\\n self.checkOK(rep)\\n\\n # check delete\\n rep = post(self.url + \\\"/search\\\", data={'name': name})\\n self.errorCatch(rep)\\n\\n # Delete Image\\n print(\\\"Delete Image\\\")\\n rep = post(self.url + \\\"/delete/image\\\", data={'name': name})\\n self.checkOK(rep)\\n\\n # Check if delete it\\n rep = post(self.url + \\\"/search/image\\\", data={'name': name})\\n self.errorCatch(rep)\",\n \"def execute(self, container_name, *args):\\n execution = self.docker.exec_create(container=container_name,\\n cmd=args,\\n tty=True)\\n\\n return self.docker.exec_start(exec_id=execution['Id'])\",\n \"def CreateDataContainer(name):\\n dc = simpl.DataContainer.New(name)\\n return dc\",\n \"def _register_container(self, container):\\n found = False\\n try:\\n for host, location, container in Container.Container.host_generator(container,\\n known_networks=self.networks.keys()):\\n websocket = \\\"ws\\\" in host.scheme or \\\"wss\\\" in host.scheme\\n secured = 'https' in host.scheme or 'wss' in host.scheme\\n http = 'http' in host.scheme or 'https' in host.scheme\\n # it might return string if there's a error in processing\\n if type(host) is not str:\\n if (host.hostname, host.port) in self.hosts:\\n existing_host: Host = self.hosts[(host.hostname, host.port)]\\n existing_host.add_container(location, container, websocket=websocket, http=http)\\n ## if any of the containers in for the virtualHost require https, the all others will be redirected to https.\\n if secured:\\n existing_host.secured = True\\n host = existing_host\\n else:\\n host.secured = secured\\n host.add_container(location, container, websocket=websocket, http=http)\\n self.hosts[(host.hostname, host.port)] = host\\n\\n if host.secured:\\n if host.hostname not in self.ssl_certificates:\\n host.ssl_expiry = self.ssl.expiry_time(host.hostname)\\n else:\\n host.ssl_expiry = self.ssl_certificates[host.hostname]\\n if (host.ssl_expiry - datetime.datetime.now()).days > 2:\\n self.ssl_certificates[host.hostname] = host.ssl_expiry\\n\\n found = True\\n self.containers.add(container.id)\\n\\n except Container.NoHostConiguration:\\n print(\\\"Skip Container:\\\", \\\"No VIRTUAL_HOST configuration\\\", \\\"Id:\\\" + container.id,\\n \\\"Name:\\\" + container.attrs[\\\"Name\\\"].replace(\\\"/\\\", \\\"\\\"), sep=\\\"\\\\t\\\")\\n except Container.UnreachableNetwork:\\n print(\\\"Skip Container:\\\", \\\"UNREACHABLE Network \\\", \\\"Id:\\\" + container.id,\\n \\\"Name:\\\" + container.attrs[\\\"Name\\\"].replace(\\\"/\\\", \\\"\\\"), sep=\\\"\\\\t\\\")\\n return found\",\n \"def container(self, container):\\n if not container.is_public():\\n container.make_public()\\n self._container = container\",\n \"def add(self, name, container):\\n\\n if name not in self.keys:\\n self.keys[name] = container\\n else:\\n raise KeyError('key already exists')\",\n \"def addDocker( self, name, **params ):\\n defaults={'dimage': self.dimage, 'hostExchangeFolder': self.hostExchangeFolder}\\n defaults.update(params)\\n return self.addHost( name, cls=Docker, **defaults )\",\n \"def __set_container_info(self):\\n self.container = \\\"{}_{}_1\\\".format(self.build, self.service.lower())\\n self.mysql_container = \\\"{}_{}-mysql_1\\\".format(self.build, self.service.lower())\",\n \"def add_machine(args):\\n session = Session()\\n # the following is used to help with code completion\\n env = Environment(name=args.environment)\\n try:\\n env = session.query(Environment).filter_by(name=args.environment).one()\\n except NoResultFound:\\n print \\\"ERROR: couldn't find environment %s\\\" % args.environment\\n sys.exit(1)\\n machine = PoolMachine(name=args.name, hostname=args.hostname, environment=env, online=True)\\n session.add(machine)\\n session.commit()\\n print repr(machine)\",\n \"def test_get_container(self):\\n pass\",\n \"def create_machine(request):\\n\\n params = params_from_request(request)\\n cloud_id = request.matchdict['cloud']\\n\\n for key in ('name', 'size'):\\n if key not in params:\\n raise RequiredParameterMissingError(key)\\n\\n key_id = params.get('key')\\n machine_name = params['name']\\n location_id = params.get('location', None)\\n image_id = params.get('image')\\n if not image_id:\\n raise RequiredParameterMissingError(\\\"image\\\")\\n # this is used in libvirt\\n disk_size = int(params.get('libvirt_disk_size', 4))\\n disk_path = params.get('libvirt_disk_path', '')\\n size_id = params['size']\\n # deploy_script received as unicode, but ScriptDeployment wants str\\n script = str(params.get('script', ''))\\n # these are required only for Linode/GCE, passing them anyway\\n image_extra = params.get('image_extra', None)\\n disk = params.get('disk', None)\\n image_name = params.get('image_name', None)\\n size_name = params.get('size_name', None)\\n location_name = params.get('location_name', None)\\n ips = params.get('ips', None)\\n monitoring = params.get('monitoring', False)\\n networks = params.get('networks', [])\\n docker_env = params.get('docker_env', [])\\n docker_command = params.get('docker_command', None)\\n script_id = params.get('script_id', '')\\n script_params = params.get('script_params', '')\\n post_script_id = params.get('post_script_id', '')\\n post_script_params = params.get('post_script_params', '')\\n async = params.get('async', False)\\n quantity = params.get('quantity', 1)\\n persist = params.get('persist', False)\\n docker_port_bindings = params.get('docker_port_bindings', {})\\n docker_exposed_ports = params.get('docker_exposed_ports', {})\\n azure_port_bindings = params.get('azure_port_bindings', '')\\n # hostname: if provided it will be attempted to assign a DNS name\\n hostname = params.get('hostname', '')\\n plugins = params.get('plugins')\\n cloud_init = params.get('cloud_init', '')\\n associate_floating_ip = params.get('associate_floating_ip', False)\\n associate_floating_ip_subnet = params.get('attach_floating_ip_subnet',\\n None)\\n project_id = params.get('project', None)\\n bare_metal = params.get('bare_metal', False)\\n # bare_metal True creates a hardware server in SoftLayer,\\n # whule bare_metal False creates a virtual cloud server\\n # hourly True is the default setting for SoftLayer hardware\\n # servers, while False means the server has montly pricing\\n softlayer_backend_vlan_id = params.get('softlayer_backend_vlan_id', None)\\n hourly = params.get('billing', True)\\n job_id = params.get('job_id')\\n job_id = params.get('job_id')\\n # The `job` variable points to the event that started the job. If a job_id\\n # is not provided, then it means that this is the beginning of a new story\\n # that starts with a `create_machine` event. If a job_id is provided that\\n # means that the current event will be part of already existing, unknown\\n # story. TODO: Provide the `job` in the request's params or query it.\\n if not job_id:\\n job = 'create_machine'\\n job_id = uuid.uuid4().hex\\n else:\\n job = None\\n\\n # these are needed for OnApp\\n size_ram = params.get('size_ram', 256)\\n size_cpu = params.get('size_cpu', 1)\\n size_disk_primary = params.get('size_disk_primary', 5)\\n size_disk_swap = params.get('size_disk_swap', 1)\\n boot = params.get('boot', True)\\n build = params.get('build', True)\\n cpu_priority = params.get('cpu_priority', 1)\\n cpu_sockets = params.get('cpu_sockets', 1)\\n cpu_threads = params.get('cpu_threads', 1)\\n port_speed = params.get('port_speed', 0)\\n hypervisor_group_id = params.get('hypervisor_group_id')\\n\\n auth_context = auth_context_from_request(request)\\n\\n try:\\n Cloud.objects.get(owner=auth_context.owner,\\n id=cloud_id, deleted=None)\\n except Cloud.DoesNotExist:\\n raise NotFoundError('Cloud does not exist')\\n\\n # compose schedule as a dict from relative parameters\\n if not params.get('schedule_type'):\\n schedule = {}\\n else:\\n if params.get('schedule_type') not in ['crontab',\\n 'interval', 'one_off']:\\n raise BadRequestError('schedule type must be one of '\\n 'these (crontab, interval, one_off)]'\\n )\\n if params.get('schedule_entry') == {}:\\n raise RequiredParameterMissingError('schedule_entry')\\n\\n schedule = {\\n 'name': params.get('name'),\\n 'description': params.get('description', ''),\\n 'action': params.get('action', ''),\\n 'script_id': params.get('schedule_script_id', ''),\\n 'schedule_type': params.get('schedule_type'),\\n 'schedule_entry': params.get('schedule_entry'),\\n 'expires': params.get('expires', ''),\\n 'start_after': params.get('start_after', ''),\\n 'max_run_count': params.get('max_run_count'),\\n 'task_enabled': bool(params.get('task_enabled', True)),\\n 'auth_context': auth_context.serialize(),\\n }\\n\\n auth_context.check_perm(\\\"cloud\\\", \\\"read\\\", cloud_id)\\n auth_context.check_perm(\\\"cloud\\\", \\\"create_resources\\\", cloud_id)\\n tags = auth_context.check_perm(\\\"machine\\\", \\\"create\\\", None) or {}\\n if script_id:\\n auth_context.check_perm(\\\"script\\\", \\\"run\\\", script_id)\\n if key_id:\\n auth_context.check_perm(\\\"key\\\", \\\"read\\\", key_id)\\n\\n # Parse tags.\\n try:\\n mtags = params.get('tags') or {}\\n if not isinstance(mtags, dict):\\n if not isinstance(mtags, list):\\n raise ValueError()\\n if not all((isinstance(t, dict) and len(t) is 1 for t in mtags)):\\n raise ValueError()\\n mtags = {key: val for item in mtags for key, val in item.items()}\\n tags.update(mtags)\\n except ValueError:\\n raise BadRequestError('Invalid tags format. Expecting either a '\\n 'dictionary of tags or a list of single-item '\\n 'dictionaries')\\n\\n args = (cloud_id, key_id, machine_name,\\n location_id, image_id, size_id,\\n image_extra, disk, image_name, size_name,\\n location_name, ips, monitoring, networks,\\n docker_env, docker_command)\\n kwargs = {'script_id': script_id,\\n 'script_params': script_params, 'script': script, 'job': job,\\n 'job_id': job_id, 'docker_port_bindings': docker_port_bindings,\\n 'docker_exposed_ports': docker_exposed_ports,\\n 'azure_port_bindings': azure_port_bindings,\\n 'hostname': hostname, 'plugins': plugins,\\n 'post_script_id': post_script_id,\\n 'post_script_params': post_script_params,\\n 'disk_size': disk_size,\\n 'disk_path': disk_path,\\n 'cloud_init': cloud_init,\\n 'associate_floating_ip': associate_floating_ip,\\n 'associate_floating_ip_subnet': associate_floating_ip_subnet,\\n 'project_id': project_id,\\n 'bare_metal': bare_metal,\\n 'tags': tags,\\n 'hourly': hourly,\\n 'schedule': schedule,\\n 'softlayer_backend_vlan_id': softlayer_backend_vlan_id,\\n 'size_ram': size_ram,\\n 'size_cpu': size_cpu,\\n 'size_disk_primary': size_disk_primary,\\n 'size_disk_swap': size_disk_swap,\\n 'boot': boot,\\n 'build': build,\\n 'cpu_priority': cpu_priority,\\n 'cpu_sockets': cpu_sockets,\\n 'cpu_threads': cpu_threads,\\n 'port_speed': port_speed,\\n 'hypervisor_group_id': hypervisor_group_id}\\n if not async:\\n ret = methods.create_machine(auth_context.owner, *args, **kwargs)\\n else:\\n args = (auth_context.owner.id, ) + args\\n kwargs.update({'quantity': quantity, 'persist': persist})\\n tasks.create_machine_async.apply_async(args, kwargs, countdown=2)\\n ret = {'job_id': job_id}\\n ret.update({'job': job})\\n return ret\",\n \"def create(credentials: ICredentials, expires=30, registry=None):\",\n \"def __init__(__self__, *,\\n container_registry_name: pulumi.Input[str],\\n resource_group_name: pulumi.Input[str],\\n instance_count: Optional[pulumi.Input[int]] = None,\\n location: Optional[pulumi.Input[str]] = None,\\n name: Optional[pulumi.Input[str]] = None,\\n tags: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,\\n tier: Optional[pulumi.Input[str]] = None,\\n virtual_network_subnet_id: Optional[pulumi.Input[str]] = None):\\n pulumi.set(__self__, \\\"container_registry_name\\\", container_registry_name)\\n pulumi.set(__self__, \\\"resource_group_name\\\", resource_group_name)\\n if instance_count is not None:\\n pulumi.set(__self__, \\\"instance_count\\\", instance_count)\\n if location is not None:\\n pulumi.set(__self__, \\\"location\\\", location)\\n if name is not None:\\n pulumi.set(__self__, \\\"name\\\", name)\\n if tags is not None:\\n pulumi.set(__self__, \\\"tags\\\", tags)\\n if tier is not None:\\n pulumi.set(__self__, \\\"tier\\\", tier)\\n if virtual_network_subnet_id is not None:\\n pulumi.set(__self__, \\\"virtual_network_subnet_id\\\", virtual_network_subnet_id)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6844575","0.67954034","0.6773649","0.6728745","0.65901256","0.64971393","0.64853096","0.64367366","0.6405615","0.6405615","0.6405615","0.6405615","0.6405615","0.6378271","0.6365454","0.6297557","0.6289078","0.61622214","0.6106284","0.6105109","0.6075229","0.6072217","0.60660356","0.6048173","0.6034355","0.6023184","0.6016147","0.6004302","0.59904987","0.5990341","0.5982586","0.5971516","0.59532744","0.59436363","0.5931689","0.5898703","0.58733845","0.5853397","0.5843229","0.5839977","0.58320624","0.5812312","0.5779124","0.5778807","0.57785237","0.57762223","0.5774948","0.5768338","0.57632804","0.567983","0.5636492","0.5634374","0.5626135","0.5613465","0.5603042","0.55916","0.5588044","0.5582788","0.5582091","0.55809176","0.5568728","0.55622935","0.5562014","0.5552078","0.5547383","0.554594","0.554409","0.5528359","0.5511162","0.54770494","0.54758185","0.54754466","0.54749256","0.54607725","0.54341257","0.54052114","0.5404079","0.53821146","0.53697884","0.5363192","0.53574884","0.5349371","0.53301907","0.530942","0.53042114","0.529997","0.5291449","0.5290248","0.5287933","0.52730227","0.52561235","0.5246039","0.5238617","0.5236889","0.52349263","0.523112","0.5228589","0.5218296","0.5217153","0.5216962","0.5205135"],"string":"[\n \"0.6844575\",\n \"0.67954034\",\n \"0.6773649\",\n \"0.6728745\",\n \"0.65901256\",\n \"0.64971393\",\n \"0.64853096\",\n \"0.64367366\",\n \"0.6405615\",\n \"0.6405615\",\n \"0.6405615\",\n \"0.6405615\",\n \"0.6405615\",\n \"0.6378271\",\n \"0.6365454\",\n \"0.6297557\",\n \"0.6289078\",\n \"0.61622214\",\n \"0.6106284\",\n \"0.6105109\",\n \"0.6075229\",\n \"0.6072217\",\n \"0.60660356\",\n \"0.6048173\",\n \"0.6034355\",\n \"0.6023184\",\n \"0.6016147\",\n \"0.6004302\",\n \"0.59904987\",\n \"0.5990341\",\n \"0.5982586\",\n \"0.5971516\",\n \"0.59532744\",\n \"0.59436363\",\n \"0.5931689\",\n \"0.5898703\",\n \"0.58733845\",\n \"0.5853397\",\n \"0.5843229\",\n \"0.5839977\",\n \"0.58320624\",\n \"0.5812312\",\n \"0.5779124\",\n \"0.5778807\",\n \"0.57785237\",\n \"0.57762223\",\n \"0.5774948\",\n \"0.5768338\",\n \"0.57632804\",\n \"0.567983\",\n \"0.5636492\",\n \"0.5634374\",\n \"0.5626135\",\n \"0.5613465\",\n \"0.5603042\",\n \"0.55916\",\n \"0.5588044\",\n \"0.5582788\",\n \"0.5582091\",\n \"0.55809176\",\n \"0.5568728\",\n \"0.55622935\",\n \"0.5562014\",\n \"0.5552078\",\n \"0.5547383\",\n \"0.554594\",\n \"0.554409\",\n \"0.5528359\",\n \"0.5511162\",\n \"0.54770494\",\n \"0.54758185\",\n \"0.54754466\",\n \"0.54749256\",\n \"0.54607725\",\n \"0.54341257\",\n \"0.54052114\",\n \"0.5404079\",\n \"0.53821146\",\n \"0.53697884\",\n \"0.5363192\",\n \"0.53574884\",\n \"0.5349371\",\n \"0.53301907\",\n \"0.530942\",\n \"0.53042114\",\n \"0.529997\",\n \"0.5291449\",\n \"0.5290248\",\n \"0.5287933\",\n \"0.52730227\",\n \"0.52561235\",\n \"0.5246039\",\n \"0.5238617\",\n \"0.5236889\",\n \"0.52349263\",\n \"0.523112\",\n \"0.5228589\",\n \"0.5218296\",\n \"0.5217153\",\n \"0.5216962\",\n \"0.5205135\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20195,"cells":{"query":{"kind":"string","value":"provides list of model ids being managed by this service"},"document":{"kind":"string","value":"def get():\n\n return {'model_ids': mgmt.get_model_ids()}"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def model_ids(self, protocol=None, groups=None):\n return [model.id for model in self.models(protocol, groups)]","def getIDs(self):\n return self.multiengine.getIDs()","def queryModelIDs(self):\n jobID = self.getJobID()\n modelCounterPairs = _clientJobsDB().modelsGetUpdateCounters(jobID)\n modelIDs = tuple(x[0] for x in modelCounterPairs)\n\n return modelIDs","def get_ids(self):\n return self._ids","def ids(self):\n return self._ids","def get_ids(self) -> List[str]:","def ids(self):\n return self.obj_to_id.values()","def object_ids(self):\n return self._extract_set('id')","def get_ids(self):\n return [item.id for item in self.items]","def ids(self):\n return list(self._id_generator())","def ids(self):\n return list(self._id_generator())","def remote_get_ids(self):\n return self.smultiengine.get_ids()","def getIDs():","def get_chain_ids(self, model_num):\n ids = []\n for chain in self.model(model_num):\n ids.append(chain.id)\n return ids","def ids(self) -> Sequence[str]:\n return pulumi.get(self, \"ids\")","def ids(self) -> Sequence[str]:\n return pulumi.get(self, \"ids\")","def ids(self):\n return ['%s:%s' % (p.NAME, self._dbattr(p.IDATTR)) for p in self.providers]","def ids(self):\n return ['%s:%s' % (p.NAME, self._dbattr(p.IDATTR)) for p in self.providers]","def objects(self):\n return self.obj_to_id.keys()","def models(self):\r\n return self.get_field('model')","def models(self):\r\n return self.get_field('model')","def getIds(self) -> List[int]:\n return list(self.users.keys())","def ids(self):\n\n return self._d.keys()","def get_static_object_ids(self) -> np.ndarray:\n return self.object_ids","def get_all_ids(self):\r\n return self.__person_repository.get_all_ids()","def get_service_ids(self) -> list[bluetooth.BluetoothUuid]:\n return [bluetooth.BluetoothUuid(i) for i in self.serviceIds()]","def ids(self):\n return (x[\"_id\"] for x in self.document._meta.collection.find(self.spec, fields = (\"_id\",)))","def user_ids(self):\r\n raise NotImplementedError","def get_es_ids(self):\n search = self.search.source(['uri']).sort(['uri'])\n es_ids = [item.meta.id for item in search.scan()]\n return es_ids","def identifiers(self) -> List[str]:\n raise NotImplementedError","def get_recordIds(self):\n record_ids = []\n for item in self.order_items:\n record_ids.append(item.get_recordId())\n \n return record_ids","def lookups(self, request, model_admin):\n list_id = [[None, \"All\"]]\n for firm in Firm.objects.all():\n list_id.append([firm.pk, firm.name])\n\n return list_id","def data(self) -> List[int]:\n return self.__ids","def data(self) -> List[int]:\n return self.__ids","def data(self) -> List[int]:\n return self.__ids","def getId(self):\n return self.base.get(\"id\", [])","def _get_user_ids(model):\n return model.objects.values_list(\"user\", flat=True).distinct(\"user\")","def model_ids(self, protocol=None, groups=None):\n\n if groups and 'train' in groups:\n # there are no models in the training set\n if len(groups) == 1: return [] #only group required, so return empty\n groups = tuple(k for k in groups if k != 'train')\n\n valid_protocols = self.protocol_names()\n protocols = bob.db.base.utils.check_parameters_for_validity(protocol,\n \"protocol\", valid_protocols)\n\n valid_groups = Model.group_choices\n groups = bob.db.base.utils.check_parameters_for_validity(groups, \"group\",\n valid_groups)\n\n retval = self.query(Model).join(Protocol)\n retval = retval.filter(Protocol.name.in_(protocols))\n\n if groups:\n retval = retval.filter(Model.group.in_(groups))\n\n retval = retval.distinct().order_by('id')\n\n return [k.name for k in retval]","def get_person_ids(self) -> np.ndarray:\n return self.person_ids","def getEventIds(self):\n eventIdsLst = []\n for event in self.eventsLst:\n eventIdsLst.append(event['id'])\n return eventIdsLst","def user_ids(self):\n return list(self.get_users())","def get_app_ids(self):\n return self.apps","def model_id(self):\n return self.comm.comm_id","def get_ids(self):\n for object_query in self.query:\n objects = self._get_objects(object_query)\n objects = self._apply_order_by_and_limit(\n objects,\n order_by=object_query.get(\"order_by\"),\n limit=object_query.get(\"limit\"),\n )\n object_query[\"ids\"] = [o.id for o in objects]\n return self.query","def getId(self):\n return _libsbml.Model_getId(self)","def get_items(self):\n return self.item_ids","def get_instances_ids(self):\n reservations = self.__get_reservations()\n instances_ids = []\n instances,_ = self.__get_multi_instances(reservations)\n for instance in instances:\n instances_ids.append(instance.id.encode(\"latin-1\"))\n return instances_ids","def admin_object_ids(self) -> Sequence[str]:\n return pulumi.get(self, \"admin_object_ids\")","def identity_ids(self) -> Optional[Sequence[str]]:\n return pulumi.get(self, \"identity_ids\")","def admin_ids(self):\n # type: () -> List[int]\n return self._admin_ids","def get_ids(self, instances):\n instance_ids = []\n for instance in instances:\n instance_ids.append(instance.id)\n return instance_ids","def get_ids(self, criteria: Dict = None):\n\n if criteria is None:\n criteria = {}\n\n ids = self.m.query(\n criteria=criteria,\n properties=[\"material_id\"])\n print(\"number %s\" % len(ids))\n ids = pd.DataFrame(ids).values.ravel().tolist()\n self.ids = ids\n return ids","def _instantiated_ids(self):\n return self._identity_map.keys()","def vertex_ids(self):\n return self.get_ids()","def processor_ids(self):\n return self._processor_ids","def get_all_master_ids(self):\r\n return self._handler.get_all_master_ids()","def populateAllElementIdList(self):\n return _libsbml.Model_populateAllElementIdList(self)","def get_ids(self):\n return self.redis.hkeys(self.feed_items)","def IDs(self, default=[{}]):\n tmp = self.data.get('ids', default)\n return [HEP.IDObject(i) for i in tmp]","def get_ids(self):\n return self._graphs.keys()","def _id_seq(self):\n return list(self.keys())","def obs_ids(self) -> list:\n return list(self._instruments.keys())","def list_ids(token):\n\n init_tenant_context(token, db)\n\n data = []\n LOGGER.debug(f\" Fetching list with known devices\")\n for id in db.session.query(Device.id).all():\n data.append(id[0])\n return data","def getAllElementIdList(self):\n return _libsbml.Model_getAllElementIdList(self)","def cluster_ids(self):\n return self.model.cluster_ids","def get_room_ids(self):\n if not self.setup():\n return []\n for room in self.homestatus.rooms:\n self.room_ids.append(room)\n return self.room_ids","def generate_model_list():\n\t\n\tmodels = [\n\t\tapi.v1.models.job.Job,\n\t]\n\treturn models","def _objects(self):\n # Assuming the document ID is called \"id\" lets us depend on fewer\n # Djangoisms than assuming it's the pk; we'd have to get\n # self.type._meta to get the name of the pk.\n return ((o.id, o) for o in self._queryset())","def user_ids(self):\n return list(self._user_ids)","def _getTagIDs(self):\n paths = self._criteria.get('paths')\n if paths:\n store = getMainStore()\n return list(store.find(Tag.id, Tag.path.is_in(paths)))","def get_all_ids(cls):\n subscriptions = db.session.query(Subscription.id).all()\n return [s.id for s in subscriptions]","def job_ids(self):\n return self.get_job_ids()","def list(self):\n return self.objects.all()","def get_control_ids(self) -> List[str]:\n return self._control_dict.keys()","def models(self):\n return self.config.models()","def vulnerability_ids():\n\n if S3VulnerabilityModel.indicator_pids is None:\n db = current.db\n table = db.vulnerability_indicator\n rows = db(table.deleted == False).select(table.parameter_id)\n S3VulnerabilityModel.indicator_pids = [i.parameter_id for i in rows]\n\n return S3VulnerabilityModel.indicator_pids","def get_assessment_ids(self):\n if not self.is_assessment_based_activity():\n raise IllegalState()\n else:\n return [Id(a) for a in self._my_map['assessmentIds']]","def all_env_ids(self) -> np.ndarray:","def _get_ids_from_hostname(self, hostname):\r\n results = self.list_instances(hostname=hostname, mask=\"id\")\r\n return [result['id'] for result in results]","def job_ids(self) -> List[str]:\n return self._db_data.job_ids","def managed_objects(self):\n return self._managed_object_list","def _get_ids_from_hostname(self, hostname):\r\n results = self.list_hardware(hostname=hostname, mask=\"id\")\r\n return [result['id'] for result in results]","def join_ids(self) -> List[int]:\n return self._join_ids","def security_list_ids(self):\n return self._security_list_ids","def list_ids(self, start: int = None, end: int = None) -> List:\n return [i.unique_id for i in self.data[start:end]]","def get_all_uid_service():\n return user_dao.get_all_uid_dao()","def getUserIds(self):\n raise BorkedGetUserIds","def get_indexable(cls):\n return cls.get_model().get_objects()","def get_rls_ids(self, table: \"BaseDatasource\") -> List[int]:\n ids = [f.id for f in self.get_rls_filters(table)]\n ids.sort() # Combinations rather than permutations\n return ids","def _get_instance_ids(instances):\n instance_ids = []\n for instance in instances:\n instance_ids.append(instance.id)\n return instance_ids","def list_package_ids(self):\n raise NotImplementedError","def complex_ids(self):\n\n return self._complex_ids","def get_current_object_ids(es, index, type):\n\n ids = []\n scan = elasticsearch.helpers.scan(\n es, index=index, doc_type=type,\n _source=False, # don't include bodies\n )\n\n for obj in scan:\n ids.append(obj['_id'])\n return ids","def models() -> list[str]:\n return list(models_url.keys())","def uids(self) -> Any:\n return self.__uids","def hvgs_ids(self):\n if not hasattr(self, '_hvgs_ids'):\n mv = myvariant.MyVariantInfo()\n self._hvgs_ids = [i['_id'] for i in\n mv.query(self.snp_loc, fields='id')['hits']]\n return self._hvgs_ids","def getFootprintId(self):\n idList = []\n for v in self.V:\n idList.append(v.uid)\n return idList","def getId(self):","def id_lst(self):\n id_set = set()\n for key in self.forward:\n for val in self.forward[key]:\n id_set.add(val)\n return list(id_set)","def get_asset_ids(self):\n if not self.is_asset_based_activity():\n raise IllegalState()\n else:\n ids = []\n for i in self._my_map['assetIds']:\n ids.append(Id(i))\n return IdList(ids)"],"string":"[\n \"def model_ids(self, protocol=None, groups=None):\\n return [model.id for model in self.models(protocol, groups)]\",\n \"def getIDs(self):\\n return self.multiengine.getIDs()\",\n \"def queryModelIDs(self):\\n jobID = self.getJobID()\\n modelCounterPairs = _clientJobsDB().modelsGetUpdateCounters(jobID)\\n modelIDs = tuple(x[0] for x in modelCounterPairs)\\n\\n return modelIDs\",\n \"def get_ids(self):\\n return self._ids\",\n \"def ids(self):\\n return self._ids\",\n \"def get_ids(self) -> List[str]:\",\n \"def ids(self):\\n return self.obj_to_id.values()\",\n \"def object_ids(self):\\n return self._extract_set('id')\",\n \"def get_ids(self):\\n return [item.id for item in self.items]\",\n \"def ids(self):\\n return list(self._id_generator())\",\n \"def ids(self):\\n return list(self._id_generator())\",\n \"def remote_get_ids(self):\\n return self.smultiengine.get_ids()\",\n \"def getIDs():\",\n \"def get_chain_ids(self, model_num):\\n ids = []\\n for chain in self.model(model_num):\\n ids.append(chain.id)\\n return ids\",\n \"def ids(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"ids\\\")\",\n \"def ids(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"ids\\\")\",\n \"def ids(self):\\n return ['%s:%s' % (p.NAME, self._dbattr(p.IDATTR)) for p in self.providers]\",\n \"def ids(self):\\n return ['%s:%s' % (p.NAME, self._dbattr(p.IDATTR)) for p in self.providers]\",\n \"def objects(self):\\n return self.obj_to_id.keys()\",\n \"def models(self):\\r\\n return self.get_field('model')\",\n \"def models(self):\\r\\n return self.get_field('model')\",\n \"def getIds(self) -> List[int]:\\n return list(self.users.keys())\",\n \"def ids(self):\\n\\n return self._d.keys()\",\n \"def get_static_object_ids(self) -> np.ndarray:\\n return self.object_ids\",\n \"def get_all_ids(self):\\r\\n return self.__person_repository.get_all_ids()\",\n \"def get_service_ids(self) -> list[bluetooth.BluetoothUuid]:\\n return [bluetooth.BluetoothUuid(i) for i in self.serviceIds()]\",\n \"def ids(self):\\n return (x[\\\"_id\\\"] for x in self.document._meta.collection.find(self.spec, fields = (\\\"_id\\\",)))\",\n \"def user_ids(self):\\r\\n raise NotImplementedError\",\n \"def get_es_ids(self):\\n search = self.search.source(['uri']).sort(['uri'])\\n es_ids = [item.meta.id for item in search.scan()]\\n return es_ids\",\n \"def identifiers(self) -> List[str]:\\n raise NotImplementedError\",\n \"def get_recordIds(self):\\n record_ids = []\\n for item in self.order_items:\\n record_ids.append(item.get_recordId())\\n \\n return record_ids\",\n \"def lookups(self, request, model_admin):\\n list_id = [[None, \\\"All\\\"]]\\n for firm in Firm.objects.all():\\n list_id.append([firm.pk, firm.name])\\n\\n return list_id\",\n \"def data(self) -> List[int]:\\n return self.__ids\",\n \"def data(self) -> List[int]:\\n return self.__ids\",\n \"def data(self) -> List[int]:\\n return self.__ids\",\n \"def getId(self):\\n return self.base.get(\\\"id\\\", [])\",\n \"def _get_user_ids(model):\\n return model.objects.values_list(\\\"user\\\", flat=True).distinct(\\\"user\\\")\",\n \"def model_ids(self, protocol=None, groups=None):\\n\\n if groups and 'train' in groups:\\n # there are no models in the training set\\n if len(groups) == 1: return [] #only group required, so return empty\\n groups = tuple(k for k in groups if k != 'train')\\n\\n valid_protocols = self.protocol_names()\\n protocols = bob.db.base.utils.check_parameters_for_validity(protocol,\\n \\\"protocol\\\", valid_protocols)\\n\\n valid_groups = Model.group_choices\\n groups = bob.db.base.utils.check_parameters_for_validity(groups, \\\"group\\\",\\n valid_groups)\\n\\n retval = self.query(Model).join(Protocol)\\n retval = retval.filter(Protocol.name.in_(protocols))\\n\\n if groups:\\n retval = retval.filter(Model.group.in_(groups))\\n\\n retval = retval.distinct().order_by('id')\\n\\n return [k.name for k in retval]\",\n \"def get_person_ids(self) -> np.ndarray:\\n return self.person_ids\",\n \"def getEventIds(self):\\n eventIdsLst = []\\n for event in self.eventsLst:\\n eventIdsLst.append(event['id'])\\n return eventIdsLst\",\n \"def user_ids(self):\\n return list(self.get_users())\",\n \"def get_app_ids(self):\\n return self.apps\",\n \"def model_id(self):\\n return self.comm.comm_id\",\n \"def get_ids(self):\\n for object_query in self.query:\\n objects = self._get_objects(object_query)\\n objects = self._apply_order_by_and_limit(\\n objects,\\n order_by=object_query.get(\\\"order_by\\\"),\\n limit=object_query.get(\\\"limit\\\"),\\n )\\n object_query[\\\"ids\\\"] = [o.id for o in objects]\\n return self.query\",\n \"def getId(self):\\n return _libsbml.Model_getId(self)\",\n \"def get_items(self):\\n return self.item_ids\",\n \"def get_instances_ids(self):\\n reservations = self.__get_reservations()\\n instances_ids = []\\n instances,_ = self.__get_multi_instances(reservations)\\n for instance in instances:\\n instances_ids.append(instance.id.encode(\\\"latin-1\\\"))\\n return instances_ids\",\n \"def admin_object_ids(self) -> Sequence[str]:\\n return pulumi.get(self, \\\"admin_object_ids\\\")\",\n \"def identity_ids(self) -> Optional[Sequence[str]]:\\n return pulumi.get(self, \\\"identity_ids\\\")\",\n \"def admin_ids(self):\\n # type: () -> List[int]\\n return self._admin_ids\",\n \"def get_ids(self, instances):\\n instance_ids = []\\n for instance in instances:\\n instance_ids.append(instance.id)\\n return instance_ids\",\n \"def get_ids(self, criteria: Dict = None):\\n\\n if criteria is None:\\n criteria = {}\\n\\n ids = self.m.query(\\n criteria=criteria,\\n properties=[\\\"material_id\\\"])\\n print(\\\"number %s\\\" % len(ids))\\n ids = pd.DataFrame(ids).values.ravel().tolist()\\n self.ids = ids\\n return ids\",\n \"def _instantiated_ids(self):\\n return self._identity_map.keys()\",\n \"def vertex_ids(self):\\n return self.get_ids()\",\n \"def processor_ids(self):\\n return self._processor_ids\",\n \"def get_all_master_ids(self):\\r\\n return self._handler.get_all_master_ids()\",\n \"def populateAllElementIdList(self):\\n return _libsbml.Model_populateAllElementIdList(self)\",\n \"def get_ids(self):\\n return self.redis.hkeys(self.feed_items)\",\n \"def IDs(self, default=[{}]):\\n tmp = self.data.get('ids', default)\\n return [HEP.IDObject(i) for i in tmp]\",\n \"def get_ids(self):\\n return self._graphs.keys()\",\n \"def _id_seq(self):\\n return list(self.keys())\",\n \"def obs_ids(self) -> list:\\n return list(self._instruments.keys())\",\n \"def list_ids(token):\\n\\n init_tenant_context(token, db)\\n\\n data = []\\n LOGGER.debug(f\\\" Fetching list with known devices\\\")\\n for id in db.session.query(Device.id).all():\\n data.append(id[0])\\n return data\",\n \"def getAllElementIdList(self):\\n return _libsbml.Model_getAllElementIdList(self)\",\n \"def cluster_ids(self):\\n return self.model.cluster_ids\",\n \"def get_room_ids(self):\\n if not self.setup():\\n return []\\n for room in self.homestatus.rooms:\\n self.room_ids.append(room)\\n return self.room_ids\",\n \"def generate_model_list():\\n\\t\\n\\tmodels = [\\n\\t\\tapi.v1.models.job.Job,\\n\\t]\\n\\treturn models\",\n \"def _objects(self):\\n # Assuming the document ID is called \\\"id\\\" lets us depend on fewer\\n # Djangoisms than assuming it's the pk; we'd have to get\\n # self.type._meta to get the name of the pk.\\n return ((o.id, o) for o in self._queryset())\",\n \"def user_ids(self):\\n return list(self._user_ids)\",\n \"def _getTagIDs(self):\\n paths = self._criteria.get('paths')\\n if paths:\\n store = getMainStore()\\n return list(store.find(Tag.id, Tag.path.is_in(paths)))\",\n \"def get_all_ids(cls):\\n subscriptions = db.session.query(Subscription.id).all()\\n return [s.id for s in subscriptions]\",\n \"def job_ids(self):\\n return self.get_job_ids()\",\n \"def list(self):\\n return self.objects.all()\",\n \"def get_control_ids(self) -> List[str]:\\n return self._control_dict.keys()\",\n \"def models(self):\\n return self.config.models()\",\n \"def vulnerability_ids():\\n\\n if S3VulnerabilityModel.indicator_pids is None:\\n db = current.db\\n table = db.vulnerability_indicator\\n rows = db(table.deleted == False).select(table.parameter_id)\\n S3VulnerabilityModel.indicator_pids = [i.parameter_id for i in rows]\\n\\n return S3VulnerabilityModel.indicator_pids\",\n \"def get_assessment_ids(self):\\n if not self.is_assessment_based_activity():\\n raise IllegalState()\\n else:\\n return [Id(a) for a in self._my_map['assessmentIds']]\",\n \"def all_env_ids(self) -> np.ndarray:\",\n \"def _get_ids_from_hostname(self, hostname):\\r\\n results = self.list_instances(hostname=hostname, mask=\\\"id\\\")\\r\\n return [result['id'] for result in results]\",\n \"def job_ids(self) -> List[str]:\\n return self._db_data.job_ids\",\n \"def managed_objects(self):\\n return self._managed_object_list\",\n \"def _get_ids_from_hostname(self, hostname):\\r\\n results = self.list_hardware(hostname=hostname, mask=\\\"id\\\")\\r\\n return [result['id'] for result in results]\",\n \"def join_ids(self) -> List[int]:\\n return self._join_ids\",\n \"def security_list_ids(self):\\n return self._security_list_ids\",\n \"def list_ids(self, start: int = None, end: int = None) -> List:\\n return [i.unique_id for i in self.data[start:end]]\",\n \"def get_all_uid_service():\\n return user_dao.get_all_uid_dao()\",\n \"def getUserIds(self):\\n raise BorkedGetUserIds\",\n \"def get_indexable(cls):\\n return cls.get_model().get_objects()\",\n \"def get_rls_ids(self, table: \\\"BaseDatasource\\\") -> List[int]:\\n ids = [f.id for f in self.get_rls_filters(table)]\\n ids.sort() # Combinations rather than permutations\\n return ids\",\n \"def _get_instance_ids(instances):\\n instance_ids = []\\n for instance in instances:\\n instance_ids.append(instance.id)\\n return instance_ids\",\n \"def list_package_ids(self):\\n raise NotImplementedError\",\n \"def complex_ids(self):\\n\\n return self._complex_ids\",\n \"def get_current_object_ids(es, index, type):\\n\\n ids = []\\n scan = elasticsearch.helpers.scan(\\n es, index=index, doc_type=type,\\n _source=False, # don't include bodies\\n )\\n\\n for obj in scan:\\n ids.append(obj['_id'])\\n return ids\",\n \"def models() -> list[str]:\\n return list(models_url.keys())\",\n \"def uids(self) -> Any:\\n return self.__uids\",\n \"def hvgs_ids(self):\\n if not hasattr(self, '_hvgs_ids'):\\n mv = myvariant.MyVariantInfo()\\n self._hvgs_ids = [i['_id'] for i in\\n mv.query(self.snp_loc, fields='id')['hits']]\\n return self._hvgs_ids\",\n \"def getFootprintId(self):\\n idList = []\\n for v in self.V:\\n idList.append(v.uid)\\n return idList\",\n \"def getId(self):\",\n \"def id_lst(self):\\n id_set = set()\\n for key in self.forward:\\n for val in self.forward[key]:\\n id_set.add(val)\\n return list(id_set)\",\n \"def get_asset_ids(self):\\n if not self.is_asset_based_activity():\\n raise IllegalState()\\n else:\\n ids = []\\n for i in self._my_map['assetIds']:\\n ids.append(Id(i))\\n return IdList(ids)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7586092","0.7151575","0.715052","0.70966995","0.6926851","0.6900199","0.6856862","0.6841992","0.6827314","0.6738882","0.6738882","0.65993893","0.6594838","0.6443746","0.64352286","0.64352286","0.6365598","0.6365598","0.6353262","0.6318382","0.6318382","0.6266775","0.62561566","0.6242754","0.6219606","0.61920106","0.6173722","0.6164314","0.6150914","0.6129479","0.6118519","0.61093795","0.6102226","0.6102226","0.6102226","0.60976833","0.6062497","0.60443366","0.6009418","0.59883964","0.59727055","0.5956065","0.59532833","0.5937877","0.5937387","0.5936713","0.5925088","0.5923023","0.5911391","0.58908","0.5875524","0.5871697","0.58684456","0.5867993","0.5859748","0.5847097","0.5844391","0.58416796","0.57921195","0.57621646","0.5761726","0.5753342","0.57513696","0.57488525","0.57416356","0.57360166","0.573109","0.57235205","0.57020825","0.56812245","0.5643504","0.5635365","0.5632672","0.56216156","0.5619926","0.5618244","0.5610004","0.56071395","0.5594407","0.5592004","0.559018","0.558762","0.5584851","0.55782044","0.5573724","0.5572293","0.5570494","0.5560303","0.5557178","0.555571","0.5552654","0.55455387","0.5544277","0.55415326","0.55412114","0.55411536","0.5532605","0.55317396","0.5530017","0.5528572"],"string":"[\n \"0.7586092\",\n \"0.7151575\",\n \"0.715052\",\n \"0.70966995\",\n \"0.6926851\",\n \"0.6900199\",\n \"0.6856862\",\n \"0.6841992\",\n \"0.6827314\",\n \"0.6738882\",\n \"0.6738882\",\n \"0.65993893\",\n \"0.6594838\",\n \"0.6443746\",\n \"0.64352286\",\n \"0.64352286\",\n \"0.6365598\",\n \"0.6365598\",\n \"0.6353262\",\n \"0.6318382\",\n \"0.6318382\",\n \"0.6266775\",\n \"0.62561566\",\n \"0.6242754\",\n \"0.6219606\",\n \"0.61920106\",\n \"0.6173722\",\n \"0.6164314\",\n \"0.6150914\",\n \"0.6129479\",\n \"0.6118519\",\n \"0.61093795\",\n \"0.6102226\",\n \"0.6102226\",\n \"0.6102226\",\n \"0.60976833\",\n \"0.6062497\",\n \"0.60443366\",\n \"0.6009418\",\n \"0.59883964\",\n \"0.59727055\",\n \"0.5956065\",\n \"0.59532833\",\n \"0.5937877\",\n \"0.5937387\",\n \"0.5936713\",\n \"0.5925088\",\n \"0.5923023\",\n \"0.5911391\",\n \"0.58908\",\n \"0.5875524\",\n \"0.5871697\",\n \"0.58684456\",\n \"0.5867993\",\n \"0.5859748\",\n \"0.5847097\",\n \"0.5844391\",\n \"0.58416796\",\n \"0.57921195\",\n \"0.57621646\",\n \"0.5761726\",\n \"0.5753342\",\n \"0.57513696\",\n \"0.57488525\",\n \"0.57416356\",\n \"0.57360166\",\n \"0.573109\",\n \"0.57235205\",\n \"0.57020825\",\n \"0.56812245\",\n \"0.5643504\",\n \"0.5635365\",\n \"0.5632672\",\n \"0.56216156\",\n \"0.5619926\",\n \"0.5618244\",\n \"0.5610004\",\n \"0.56071395\",\n \"0.5594407\",\n \"0.5592004\",\n \"0.559018\",\n \"0.558762\",\n \"0.5584851\",\n \"0.55782044\",\n \"0.5573724\",\n \"0.5572293\",\n \"0.5570494\",\n \"0.5560303\",\n \"0.5557178\",\n \"0.555571\",\n \"0.5552654\",\n \"0.55455387\",\n \"0.5544277\",\n \"0.55415326\",\n \"0.55412114\",\n \"0.55411536\",\n \"0.5532605\",\n \"0.55317396\",\n \"0.5530017\",\n \"0.5528572\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70333165"},"document_rank":{"kind":"string","value":"4"}}},{"rowIdx":20196,"cells":{"query":{"kind":"string","value":"MS Access can't handle complex Decimal types"},"document":{"kind":"string","value":"def convert_data_type(self, datatype):\n converted = Engine.convert_data_type(self, datatype)\n if \"NUMERIC\" in converted:\n converted = \"NUMERIC\"\n elif \"VARCHAR\" in converted:\n try:\n length = int(converted.split('(')[1].split(')')[0].split(',')[0])\n if length > 255:\n converted = \"TEXT\"\n except BaseException:\n pass\n return converted"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def test_decimal_e(cursor: pyodbc.Cursor):\n value = Decimal((0, (1, 2, 3), 5)) # prints as 1.23E+7\n cursor.execute(\"create table t1(d decimal(10, 2))\")\n cursor.execute(\"insert into t1 values (?)\", value)\n result = cursor.execute(\"select * from t1\").fetchone()[0]\n assert result == value","def test_numerics_broken_inspection(self):\n\n metadata = self.metadata\n\n # this test requires cx_oracle 5\n\n foo = Table('foo', metadata,\n Column('idata', Integer),\n Column('ndata', Numeric(20, 2)),\n Column('ndata2', Numeric(20, 2)),\n Column('nidata', Numeric(5, 0)),\n Column('fdata', Float()),\n )\n foo.create()\n\n foo.insert().execute(\n {'idata':5, 'ndata':decimal.Decimal(\"45.6\"),\n 'ndata2':decimal.Decimal(\"45.0\"),\n 'nidata':decimal.Decimal('53'), 'fdata':45.68392},\n )\n\n stmt = \"\"\"\n SELECT\n idata,\n ndata,\n ndata2,\n nidata,\n fdata\n FROM foo\n \"\"\"\n\n\n row = testing.db.execute(stmt).fetchall()[0]\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, int, float])\n eq_(\n row,\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), 53, 45.683920000000001)\n )\n\n # with a nested subquery,\n # both Numeric values that don't have decimal places, regardless\n # of their originating type, come back as ints with no useful\n # typing information beyond \"numeric\". So native handler\n # must convert to int.\n # this means our Decimal converters need to run no matter what.\n # totally sucks.\n\n stmt = \"\"\"\n SELECT\n (SELECT (SELECT idata FROM foo) FROM DUAL) AS idata,\n (SELECT CAST((SELECT ndata FROM foo) AS NUMERIC(20, 2)) FROM DUAL)\n AS ndata,\n (SELECT CAST((SELECT ndata2 FROM foo) AS NUMERIC(20, 2)) FROM DUAL)\n AS ndata2,\n (SELECT CAST((SELECT nidata FROM foo) AS NUMERIC(5, 0)) FROM DUAL)\n AS nidata,\n (SELECT CAST((SELECT fdata FROM foo) AS FLOAT) FROM DUAL) AS fdata\n FROM dual\n \"\"\"\n row = testing.db.execute(stmt).fetchall()[0]\n eq_([type(x) for x in row], [int, decimal.Decimal, int, int, decimal.Decimal])\n eq_(\n row,\n (5, decimal.Decimal('45.6'), 45, 53, decimal.Decimal('45.68392'))\n )\n\n row = testing.db.execute(text(stmt,\n typemap={\n 'idata':Integer(),\n 'ndata':Numeric(20, 2),\n 'ndata2':Numeric(20, 2),\n 'nidata':Numeric(5, 0),\n 'fdata':Float()\n })).fetchall()[0]\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, decimal.Decimal, float])\n eq_(row,\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), decimal.Decimal('53'), 45.683920000000001)\n )\n\n stmt = \"\"\"\n SELECT\n anon_1.idata AS anon_1_idata,\n anon_1.ndata AS anon_1_ndata,\n anon_1.ndata2 AS anon_1_ndata2,\n anon_1.nidata AS anon_1_nidata,\n anon_1.fdata AS anon_1_fdata\n FROM (SELECT idata, ndata, ndata2, nidata, fdata\n FROM (\n SELECT\n (SELECT (SELECT idata FROM foo) FROM DUAL) AS idata,\n (SELECT CAST((SELECT ndata FROM foo) AS NUMERIC(20, 2))\n FROM DUAL) AS ndata,\n (SELECT CAST((SELECT ndata2 FROM foo) AS NUMERIC(20, 2))\n FROM DUAL) AS ndata2,\n (SELECT CAST((SELECT nidata FROM foo) AS NUMERIC(5, 0))\n FROM DUAL) AS nidata,\n (SELECT CAST((SELECT fdata FROM foo) AS FLOAT) FROM DUAL)\n AS fdata\n FROM dual\n )\n WHERE ROWNUM >= 0) anon_1\n \"\"\"\n row =testing.db.execute(stmt).fetchall()[0]\n eq_([type(x) for x in row], [int, decimal.Decimal, int, int, decimal.Decimal])\n eq_(row, (5, decimal.Decimal('45.6'), 45, 53, decimal.Decimal('45.68392')))\n\n row = testing.db.execute(text(stmt,\n typemap={\n 'anon_1_idata':Integer(),\n 'anon_1_ndata':Numeric(20, 2),\n 'anon_1_ndata2':Numeric(20, 2),\n 'anon_1_nidata':Numeric(5, 0),\n 'anon_1_fdata':Float()\n })).fetchall()[0]\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, decimal.Decimal, float])\n eq_(row,\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), decimal.Decimal('53'), 45.683920000000001)\n )\n\n row = testing.db.execute(text(stmt,\n typemap={\n 'anon_1_idata':Integer(),\n 'anon_1_ndata':Numeric(20, 2, asdecimal=False),\n 'anon_1_ndata2':Numeric(20, 2, asdecimal=False),\n 'anon_1_nidata':Numeric(5, 0, asdecimal=False),\n 'anon_1_fdata':Float(asdecimal=True)\n })).fetchall()[0]\n eq_([type(x) for x in row], [int, float, float, float, decimal.Decimal])\n eq_(row,\n (5, 45.6, 45, 53, decimal.Decimal('45.68392'))\n )","def convert_decimal(value: t.Any) -> Decimal:\n return Decimal(value)","def transform_bson(self, value):\r\n return value.to_decimal()","def transform_bson(self, value):\r\n return value.to_decimal()","def _serialize_decimal(val):\n return float(val)","def to_python(self, value):\n if not value or value is models.fields.NOT_PROVIDED:\n value = None\n elif not isinstance(value, Decimal):\n try:\n value = Decimal(value)\n except InvalidOperation:\n value = None\n return value","def addDecimal(self):\n\t\t# set the decimal flag to true\n\t\tself.decimal = True","def form_Decimal(request):\n schema = schemaish.Structure()\n schema.add('myDecimalField', schemaish.Decimal())\n form = formish.Form(schema, 'form')\n return form","def decode(val):\n if isinstance(val, Decimal):\n return float(val)\n return val","def decimal_default(obj):\n if isinstance(obj, Decimal):\n return float(obj)\n raise TypeError","def test_decimal_default(self):\r\n default = D('2.00')\r\n prop = Decimal(default=default, required=True)\r\n self.assertEqual(prop.to_database(None), prop.to_database(default))","def isdecimal(self):\n return isdecimal(self)","def d(val, *args, **kwargs):\n if not isinstance(val, Decimal):\n val_str = unicode(val)\n val_d = Decimal(val_str, *args, **kwargs)\n else:\n val_d = val\n return val_d","def is_decimal(obj):\n\n return isinstance(obj, Decimal)","def test_normal_decimal_input(self):\r\n ws_leader = \"S. O'Neal (14.9)\"\r\n res = treat_input(ws_leader, type=\"float\")\r\n assert res == 14.9","def test_decimal_update(self):\r\n vm = Decimal.value_manager(None, None, D('5.00'))\r\n assert not vm.changed\r\n vm.value = D('4.00')\r\n assert vm.changed","def decimal(self, column, length=17, precision=6, nullable=False):\n self._last_column = self.table.add_column(\n column, \"decimal\", length=(length, precision), nullable=nullable\n )\n return self","def _validate_decimal(d: decimal.Decimal, precision: int, scale: int) -> None:\n _, digits, exp = d.as_tuple()\n # Precision represents the number of digits that can be stored.\n if len(digits) > precision:\n raise ValueError(\n \"decimal value has more digits than is legal according \"\n + \"to the schema's precision\"\n )\n\n # Scale represents the number of digits held after the decimal point.\n if exp < 0:\n if -exp > scale:\n raise ValueError(\n \"decimal value requires greater decimal scale than is \"\n + \"legal according to the schema\"\n )","def _repr_(self):\n return \"Complex Field with %s bits of precision\"%self._prec","def test_decimal_inplace_update(self):\r\n vm = Decimal.value_manager(None, None, D('5.00'))\r\n assert not vm.changed\r\n vm.value += D('1.00')\r\n assert vm.changed","def test_cast_non_numeric_true():\n assert _currency_column_to_numeric(\"foo\", {\"foo\": 42}) == 42","def adapt_decimal(value: t.Any) -> str:\n return str(value)","async def test_decimal_field(database_url):\n\n async with Database(database_url) as database:\n async with database.transaction(force_rollback=True):\n price = decimal.Decimal(\"0.700000000000001\")\n\n # execute()\n query = prices.insert()\n values = {\"price\": price}\n await database.execute(query, values)\n\n # fetch_all()\n query = prices.select()\n results = await database.fetch_all(query=query)\n assert len(results) == 1\n if database_url.startswith(\"sqlite\"):\n # aiosqlite does not support native decimals --> a roud-off error is expected\n assert results[0][\"price\"] == pytest.approx(price)\n else:\n assert results[0][\"price\"] == price","def complex_value(self) -> global___Expression.ComplexValue:","def to_prec(self, prec):\n return ComplexField(prec)","def get_decimal(self):\n return self.decimal","def testSetPowerWithFloat(self):\n self.node.power = 100.1\n\n self.assertEqual(\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\n self.node.power\n )","def isdecimal(a): \n if not _is_unicode(a):\n raise TypeError(\n \"isdecimal is only available for Unicode strings and arrays\")\n return _vec_string(a, bool_, 'isdecimal')","def test_numeric(self):\n conn = self.database.connection()\n cursor = conn.cursor()\n dialect = self.database.dialect()\n dbapi = self.database.dbapi()\n query = dialect.translate('DROP TABLE test_numeric')\n try:\n cursor.execute(query)\n except dbapi.Error:\n conn.rollback()\n query = dialect.translate('CREATE TABLE test_numeric ' \\\n '( value NUMERIC(100,50) NOT NULL )')\n cursor.execute(query)\n data = []\n query = 'INSERT INTO test_numeric VALUES (%s)'\n for i in range(100):\n int = random.getrandbits(150)\n frac = random.getrandbits(150)\n item = decimal.Decimal('%d.%s' % (int, frac))\n data.append(item)\n cursor.execute(query, (item,))\n query = 'SELECT * FROM test_numeric'\n cursor.execute(query)\n result = cursor.fetchall()\n for row in result:\n item = row[0]\n assert isinstance(item, decimal.Decimal)\n assert item in data\n data.remove(item)\n query = dialect.translate('DELETE FROM test_numeric')\n cursor.execute(query)\n query = dialect.translate('DROP TABLE test_numeric')\n cursor.execute(query)\n conn.commit()","def foreign_translate(object):\n if object == None:\n return Null\n if isinstance(object, (int, long, float)):\n return Decimal(object)\n return object","def get_column_type(cls, **kwargs: Any) -> Any:\n precision = kwargs.get(\"precision\")\n scale = kwargs.get(\"scale\")\n return sqlalchemy.DECIMAL(precision=precision, scale=scale)","def test_double_precision(self):\n conn = self.database.connection()\n cursor = conn.cursor()\n dialect = self.database.dialect()\n dbapi = self.database.dbapi()\n query = dialect.translate('DROP TABLE test_double_precision')\n try:\n cursor.execute(query)\n except dbapi.Error:\n conn.rollback()\n query = dialect.translate('CREATE TABLE test_double_precision ' \\\n '( value DOUBLE PRECISION NOT NULL )')\n cursor.execute(query)\n data = []\n query = 'INSERT INTO test_double_precision VALUES (%s)'\n for i in range(100):\n item = random.random()\n data.append(item)\n cursor.execute(query, (item,))\n query = 'SELECT * FROM test_double_precision'\n cursor.execute(query)\n result = cursor.fetchall()\n for row in result:\n item = row[0]\n assert isinstance(item, float)\n for i,f in enumerate(data):\n if abs(f - item) < 1e-12:\n break\n else:\n assert False, 'Item not found'\n query = dialect.translate('DELETE FROM test_double_precision')\n cursor.execute(query)\n query = dialect.translate('DROP TABLE test_double_precision')\n cursor.execute(query)\n conn.commit()","def cast(elem, psql_type):\n if psql_type == 'real':\n return float(format(elem, '.6g'))\n elif psql_type == 'double precision':\n return float(format(elem, '.15g'))\n elif psql_type == 'timestamp':\n if isinstance(elem, pd.Timestamp):\n return elem.to_pydatetime()\n else:\n return elem\n elif psql_type == 'text':\n if type(elem) == float:\n return \"NaN\"\n return str(elem)\n else:\n return elem","def test_float():\n floatify = fields.FloatField().adapt\n\n for input, expect in [\n (1.1, 1.1),\n (11, 11.0),\n (int(5.7), 5)\n ]:\n assert floatify(input) == expect","def default(self, o):\n if isinstance(o, Decimal):\n return float(o)\n return super(DecimalJSONEncoder, self).default(o)","def str_to_decimal(self, decimal_str, key, enforce_row_break=False):\n\n break_err = False\n break_err_msg = \"\"\n\n try:\n decimal_value = Decimal(decimal_str) \n except Exception as err:\n\n if key == \"Payment Amount\" and decimal_str == \"\":\n decimal_value = None \n\n elif enforce_row_break: # assign none to value and generate error \n decimal_value = None\n\n\n break_err = True\n break_err_msg = \"Couldn't convert %s to decimal\" % key\n\n # add corresponding error for the row\n self.update_row_err(break_err, break_err_msg)\n\n else:\n decimal_value = 0.00 # assign 0.00 to decimal value\"\"\"\n \n return decimal_value","def test_format_nested_fields() -> None:\n value: Decimal = Decimal(\"12.34567\")\n width: int = 10\n precision: int = 5\n assert f\"result: {value:{width}.{precision}}\" == \"result: 12.346\"","def test_float():\n assert float(Quantity(1, unit('m'))) == float(1)","def add_support_for_floats_to_dynamodb():\n\n # Ignore loss of precision rather than raising exception\n DYNAMODB_CONTEXT.clear_traps()\n\n # Keep a reference to the original serialization methods\n boto3_serialize_orig = TypeSerializer.serialize\n boto3_deserialize_orig = TypeDeserializer.deserialize\n\n # Wrap serialization methods to support floats\n def boto3_serialize(self, value):\n if isinstance(value, float):\n value = Decimal(value)\n return boto3_serialize_orig(self, value)\n\n def boto3_deserialize(self, value):\n value = boto3_deserialize_orig(self, value)\n if isinstance(value, Decimal):\n value = float(value)\n return value\n\n # Replace the serialization methods with wrapped versions\n TypeSerializer.serialize = boto3_serialize\n TypeDeserializer.deserialize = boto3_deserialize","def _assert_valid_value_and_cast(value):\n if isinstance(value, float):\n return float_to_decimal(value)\n if isinstance(value, int):\n return Decimal(value)\n if isinstance(value, Decimal):\n return value\n\n raise AssertionError(\"{0} is not a valid numeric type.\".\n format(value))","def transform_python(self, value):\r\n return Decimal128(value)","def transform_python(self, value):\r\n return Decimal128(value)","def test_cast_non_numeric_false():\n assert _currency_column_to_numeric(\"10 dollars\", {\"foo\": 42}) == \"10\"","def ijson_decimal_to_float(event):\n if event[1] == 'number' and isinstance(event[2], decimal.Decimal):\n return event[0], event[1], float(event[2])\n else:\n return event","def EvaluateFields(self, *float, **kwargs):\n ...","def test_prepare_value_limit_denominator(self):\n field = DecimalFractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def testSatBecomesDecimal(self):\n sat = 3\n\n self.cc.sat = sat\n\n self.assertEqual(\n Decimal(sat),\n self.cc.sat\n )","def _cast_to_number(self, key):\n q = DBSession.query(cast(self.db_value.value, Float)). \\\n join(self.db_tag). \\\n join(self.db_key). \\\n filter(self.db_key.key == key)\n try:\n q.all()\n return True\n except:\n return False","def num(value):\n value = Decimal(value)\n return value","def to_float_complex(self):\r\n return eval(str(self))","def test_calculate_retention_fee():\n assert calculate_retention_fee(2578) == Decimal('128.91')","def testSetWithFloat(self):\n self.node.sat = 100.1\n\n self.assertEqual(\n Decimal('100.1'),\n self.node.sat\n )","def _real_field(self):\n try:\n return self.__real_field\n except AttributeError:\n from .real_mpfr import RealField\n self.__real_field = RealField(self._prec)\n return self.__real_field","def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None):\n strvalue = super().adapt_decimalfield_value(value, max_digits, decimal_places)\n return Decimal(strvalue)","def __float__(self):\n return float(self.number)","def _(primitive_type: DecimalType, value: Decimal) -> bytes:\n _, digits, exponent = value.as_tuple()\n exponent = abs(int(exponent))\n if exponent != primitive_type.scale:\n raise ValueError(f\"Cannot serialize value, scale of value does not match type {primitive_type}: {exponent}\")\n elif len(digits) > primitive_type.precision:\n raise ValueError(\n f\"Cannot serialize value, precision of value is greater than precision of type {primitive_type}: {len(digits)}\"\n )\n\n return decimal_to_bytes(value)","def test_vat_float(self):\n value = 412.32\n self.assertAlmostEqual(cr.vat(value), value * 0.15, places=2)","def __float__( self ):\r\n\t\tif ( types.ComplexType in ( type( self.numerator ), type( self.denominator ) ) ):\r\n\t\t\tn,d = self.numerator, self.denominator\r\n\t\t\tif ( type( n ) == types.ComplexType ): n = abs( n )\r\n\t\t\tif ( type( d ) == types.ComplexType ): d = abs( d )\r\n\t\t\treturn n / d\r\n\t\treturn float( self.numerator ) / self.denominator","def float_format(self):\n ...","def validate_decimal(v: str, field: Field):\n field_info = field.field_info\n inclusive = field_info.ge is not None or field_info.le is not None\n min_value = field_info.gt if field_info.gt is not None else field_info.ge\n min_value = Decimal(min_value) if min_value is not None else min_value\n max_value = field_info.lt if field_info.lt is not None else field_info.le\n max_value = Decimal(max_value) if max_value is not None else max_value\n ret = validate_decimal(v, min_value, max_value, inclusive)\n if ret is not None:\n raise ValueError(ret)\n return v","def __new__(self, *args, **kwargs):\n if not self._precision is None:\n if len(args):\n value = Decimal(args[0]).quantize(Decimal(str(self._precision)))\n else:\n value = Decimal(0)\n elif len(args):\n value = Decimal(args[0])\n else:\n value = Decimal(0)\n obj = Decimal.__new__(self, value, **kwargs)\n return obj","def Ro_decimal_constr(x_par):\n if len(x_par) == 3:\n return x_par[0] * x_par[2] / x_par[1]\n else:\n return x_par[0] / x_par[1]","def convert_dollars(df,col_name):\n df[col_name] = df[col_name].replace('[^.0-9]','',regex=True).astype(float)\n return df","def arrow_type_for(column_name, cx_oracle_type, precision, scale):\n\n # In the schema, these are bare NUMBER columns, so erroneously come back as floats.\n if column_name in ['AVPID', 'TUMOUR_AVPID']:\n return pa.int64()\n\n if cx_oracle_type == cx_Oracle.DB_TYPE_NUMBER:\n if scale == 0:\n if precision == 1:\n return pa.bool_()\n else:\n return pa.int64()\n else:\n return pa.float64()\n else:\n return type_map.get(cx_oracle_type)","def RestrictedPrecisionDecimalType(*args, **kwargs):\n precision = kwargs.pop(\"precision\", False)\n class RestrictedPrecisionDecimal(Decimal):\n \"\"\"\n Class extending decimal.Decimal to restrict the precision that is\n stored, supporting the fraction-digits argument of the YANG decimal64\n type.\n \"\"\"\n _precision = 10.0**(-1.0*int(precision))\n def __new__(self, *args, **kwargs):\n \"\"\"\n Overloads the decimal __new__ function in order to round the input\n value to the new value.\n \"\"\"\n if not self._precision is None:\n if len(args):\n value = Decimal(args[0]).quantize(Decimal(str(self._precision)))\n else:\n value = Decimal(0)\n elif len(args):\n value = Decimal(args[0])\n else:\n value = Decimal(0)\n obj = Decimal.__new__(self, value, **kwargs)\n return obj\n return type(RestrictedPrecisionDecimal(*args, **kwargs))","def somme(self) -> Numeric:\n return query_sum(\n self.offre_set.filter(valide=True),\n \"prix\",\n output_field=models.DecimalField(),\n )","def test_prepare_value_int(self):\n field = DecimalFractionField()\n result = field.prepare_value(1)\n self.assertEqual(\"1\", result)","def conform_input_data(rowdict):\n # rowdict['Value'] = float(rowdict['Value'])\n rowdict['TimeStamp'] = TS_to_date(rowdict['TimeStamp'][:19])\n for floatcolumn in ['LowPx','OpenPx','ClosePx','QuoteCount','HighPx','TradeCount']:\n if floatcolumn in rowdict:\n rowdict[floatcolumn] = float(rowdict[floatcolumn])\n return rowdict","def test_convert_amounts(self):\n pass","def get_float2(self):\n pass","def test_non_cast_input():\n assert _currency_column_to_numeric(\"-1,000,000 yen\") == \"-1000000\"","def test_many_decimal_data_points(self):\r\n values = [3.14, 42, 2.718281, 1.41421, 10]\r\n expect_mean_result = 11.854498\r\n expected_sd_result = 15.36621\r\n result = multipoint_mean_sd(values)\r\n\r\n self.assertAlmostEqual(expect_mean_result, result['mean_result'], 4)\r\n self.assertAlmostEqual(expected_sd_result, result['sd_result'], 4)","def from_RealField(K1, a, K0):\n p, q = K0.to_rational(a)\n\n if q == 1:\n return K1.dtype(K1.dom.dtype(p))","def monetary_amount_valid(record, field_name='price', min=1, max=10):\n monetary_amount = record[field_name]\n assert isinstance(monetary_amount, float)\n string_price = str(monetary_amount)\n decimal = string_price.split(\".\")[1]\n assert min <= monetary_amount <= max and len(decimal) <= 2","def _convert_to_decimal(value):\n d0 = value[0][0]\n d1 = value[0][1]\n d = float(d0) / float(d1)\n \n m0 = value[1][0]\n m1 = value[1][1]\n m = float(m0) / float(m1)\n \n s0 = value[2][0]\n s1 = value[2][1]\n s = float(s0) / float(s1)\n \n return d + (m / 60.0) + (s / 3600.0)","def default(self, o: Decimal) -> Union[int, float]:\n if isinstance(o, Decimal):\n # NOTE: The below is potentially a HUGE MISTAKE and an\n # unnecessary OVER ENGINEERING! but this works. This is\n # not required as such because we can get around this by\n # converting everything to float by default but it makes\n # more sense to return response of ints as int and float as\n # float.\n return int(o) if float(o).is_integer() else float(o)\n return super().default(o)","def test_prepare_value_limit_denominator(self):\n field = FractionField(limit_denominator=3)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)","def __to_value(self, s):\r\n if isinstance(s, list):\r\n s = s[0]\r\n if s is None:\r\n return None\r\n elif s.strip() == '':\r\n return None\r\n else:\r\n return Decimal(s)","def validate_insert(self, s, internal=True):\n super(FieldNumeric, self).validate_insert(s, internal) # mandatory check\n if s:\n try:\n float(s)\n except:\n raise FilemanError(\"\"\"[%s] is not a valid number\"\"\" % s)","def normalisePrice(raw):\n if raw:\n return Decimal(str(raw)).to_eng_string()\n else:\n return None","def is_qty_decimal(self):\n return self._is_qty_decimal","def test_double_default(self):\r\n default = 7.0\r\n prop = Double(default=default, required=True)\r\n self.assertEqual(prop.to_database(None), prop.to_database(default))","def __round__(self, ???):","def testSetSlopeWithFloat(self):\n self.node.slope = 100.1\n\n self.assertEqual(\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\n self.node.slope\n )","def somme(self) -> Numeric:\n return query_sum(self.offres(), \"prix\", output_field=models.DecimalField())","def __float__(self) -> float:\n return self._translate_in_type(float, self.integer)","def test_prepare_value_coerce_thirds(self):\n field = DecimalFractionField(coerce_thirds=True)\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)\n\n result = field.prepare_value(Decimal(1 / 3.0))\n self.assertEqual(\"1/3\", result)\n\n result = field.prepare_value(Decimal(2 / 3.0))\n self.assertEqual(\"2/3\", result)\n\n result = field.prepare_value(Decimal(2 / 6.0))\n self.assertEqual(\"1/3\", result)\n\n result = field.prepare_value(Decimal(4 / 6.0))\n self.assertEqual(\"2/3\", result)\n\n result = field.prepare_value(Decimal(4 / 3.0))\n self.assertEqual(\"1 1/3\", result)\n\n result = field.prepare_value(Decimal(5 / 3.0))\n self.assertEqual(\"1 2/3\", result)","def convert_types(cls, value):\n if type(value) in (datetime, date):\n return time.mktime(value.timetuple())\n elif isinstance(value, Decimal):\n return float(value)\n else:\n return value","def validate(cls, **kwargs: Any) -> None:\n precision = kwargs.get(\"precision\")\n scale = kwargs.get(\"scale\")\n if precision is None or precision < 0 or scale is None or scale < 0:\n raise ModelDefinitionError(\n \"Parameters scale and precision are required for field Decimal\"\n )","def get_column_type(cls, **kwargs: Any) -> Any:\n return sqlalchemy.Float()","def getDouble(self, int: int, int2: int) -> float:\n ...","def _get_number(self):\n return Decimal(str(self)[1:])","def test_calculate_base_monthly_payment():\n assert calculate_base_monthly_payment(2578, 5) == Decimal('489.82')","def get_real(val, precision):\n if precision == \"single\":\n return numpy.float32(val)\n elif precision == \"double\":\n return numpy.float64(val)\n else:\n raise ValueError (\"precision %s not supported!\"%(precision))","def real_float_to_decimal_cast_cases(float_ty, max_precision):\n mantissa_digits = 16\n for precision in range(1, max_precision, 3):\n for scale in range(0, precision, 2):\n epsilon = 2 * 10**max(precision - mantissa_digits, 0)\n abs_minval = largest_scaled_float_not_above(epsilon, scale)\n abs_maxval = largest_scaled_float_not_above(\n 10**precision - epsilon, scale)\n yield FloatToDecimalCase(precision, scale, abs_minval)\n yield FloatToDecimalCase(precision, scale, abs_maxval)","def __float__(self):\n return self.num / self.denom # result of / is of type float","def convert(self, value):\n return self.ASCIIToDecimal(value)","def testPowerDefault(self):\n self.assertEqual(\n (Decimal('1.0'), Decimal('1.0'), Decimal('1.0')),\n self.node.power\n )","def testSetOffsetWithFloat(self):\n self.node.offset = 100.1\n\n self.assertEqual(\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\n self.node.offset\n )","def to_numerical(table, column_name):\n def replace(entry):\n return float(entry)\n assert (isinstance(table, Table)), \"Input not a supported type.\"\n column = table.apply(replace, column_name)\n return table.append_column(column_name, column)"],"string":"[\n \"def test_decimal_e(cursor: pyodbc.Cursor):\\n value = Decimal((0, (1, 2, 3), 5)) # prints as 1.23E+7\\n cursor.execute(\\\"create table t1(d decimal(10, 2))\\\")\\n cursor.execute(\\\"insert into t1 values (?)\\\", value)\\n result = cursor.execute(\\\"select * from t1\\\").fetchone()[0]\\n assert result == value\",\n \"def test_numerics_broken_inspection(self):\\n\\n metadata = self.metadata\\n\\n # this test requires cx_oracle 5\\n\\n foo = Table('foo', metadata,\\n Column('idata', Integer),\\n Column('ndata', Numeric(20, 2)),\\n Column('ndata2', Numeric(20, 2)),\\n Column('nidata', Numeric(5, 0)),\\n Column('fdata', Float()),\\n )\\n foo.create()\\n\\n foo.insert().execute(\\n {'idata':5, 'ndata':decimal.Decimal(\\\"45.6\\\"),\\n 'ndata2':decimal.Decimal(\\\"45.0\\\"),\\n 'nidata':decimal.Decimal('53'), 'fdata':45.68392},\\n )\\n\\n stmt = \\\"\\\"\\\"\\n SELECT\\n idata,\\n ndata,\\n ndata2,\\n nidata,\\n fdata\\n FROM foo\\n \\\"\\\"\\\"\\n\\n\\n row = testing.db.execute(stmt).fetchall()[0]\\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, int, float])\\n eq_(\\n row,\\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), 53, 45.683920000000001)\\n )\\n\\n # with a nested subquery,\\n # both Numeric values that don't have decimal places, regardless\\n # of their originating type, come back as ints with no useful\\n # typing information beyond \\\"numeric\\\". So native handler\\n # must convert to int.\\n # this means our Decimal converters need to run no matter what.\\n # totally sucks.\\n\\n stmt = \\\"\\\"\\\"\\n SELECT\\n (SELECT (SELECT idata FROM foo) FROM DUAL) AS idata,\\n (SELECT CAST((SELECT ndata FROM foo) AS NUMERIC(20, 2)) FROM DUAL)\\n AS ndata,\\n (SELECT CAST((SELECT ndata2 FROM foo) AS NUMERIC(20, 2)) FROM DUAL)\\n AS ndata2,\\n (SELECT CAST((SELECT nidata FROM foo) AS NUMERIC(5, 0)) FROM DUAL)\\n AS nidata,\\n (SELECT CAST((SELECT fdata FROM foo) AS FLOAT) FROM DUAL) AS fdata\\n FROM dual\\n \\\"\\\"\\\"\\n row = testing.db.execute(stmt).fetchall()[0]\\n eq_([type(x) for x in row], [int, decimal.Decimal, int, int, decimal.Decimal])\\n eq_(\\n row,\\n (5, decimal.Decimal('45.6'), 45, 53, decimal.Decimal('45.68392'))\\n )\\n\\n row = testing.db.execute(text(stmt,\\n typemap={\\n 'idata':Integer(),\\n 'ndata':Numeric(20, 2),\\n 'ndata2':Numeric(20, 2),\\n 'nidata':Numeric(5, 0),\\n 'fdata':Float()\\n })).fetchall()[0]\\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, decimal.Decimal, float])\\n eq_(row,\\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), decimal.Decimal('53'), 45.683920000000001)\\n )\\n\\n stmt = \\\"\\\"\\\"\\n SELECT\\n anon_1.idata AS anon_1_idata,\\n anon_1.ndata AS anon_1_ndata,\\n anon_1.ndata2 AS anon_1_ndata2,\\n anon_1.nidata AS anon_1_nidata,\\n anon_1.fdata AS anon_1_fdata\\n FROM (SELECT idata, ndata, ndata2, nidata, fdata\\n FROM (\\n SELECT\\n (SELECT (SELECT idata FROM foo) FROM DUAL) AS idata,\\n (SELECT CAST((SELECT ndata FROM foo) AS NUMERIC(20, 2))\\n FROM DUAL) AS ndata,\\n (SELECT CAST((SELECT ndata2 FROM foo) AS NUMERIC(20, 2))\\n FROM DUAL) AS ndata2,\\n (SELECT CAST((SELECT nidata FROM foo) AS NUMERIC(5, 0))\\n FROM DUAL) AS nidata,\\n (SELECT CAST((SELECT fdata FROM foo) AS FLOAT) FROM DUAL)\\n AS fdata\\n FROM dual\\n )\\n WHERE ROWNUM >= 0) anon_1\\n \\\"\\\"\\\"\\n row =testing.db.execute(stmt).fetchall()[0]\\n eq_([type(x) for x in row], [int, decimal.Decimal, int, int, decimal.Decimal])\\n eq_(row, (5, decimal.Decimal('45.6'), 45, 53, decimal.Decimal('45.68392')))\\n\\n row = testing.db.execute(text(stmt,\\n typemap={\\n 'anon_1_idata':Integer(),\\n 'anon_1_ndata':Numeric(20, 2),\\n 'anon_1_ndata2':Numeric(20, 2),\\n 'anon_1_nidata':Numeric(5, 0),\\n 'anon_1_fdata':Float()\\n })).fetchall()[0]\\n eq_([type(x) for x in row], [int, decimal.Decimal, decimal.Decimal, decimal.Decimal, float])\\n eq_(row,\\n (5, decimal.Decimal('45.6'), decimal.Decimal('45'), decimal.Decimal('53'), 45.683920000000001)\\n )\\n\\n row = testing.db.execute(text(stmt,\\n typemap={\\n 'anon_1_idata':Integer(),\\n 'anon_1_ndata':Numeric(20, 2, asdecimal=False),\\n 'anon_1_ndata2':Numeric(20, 2, asdecimal=False),\\n 'anon_1_nidata':Numeric(5, 0, asdecimal=False),\\n 'anon_1_fdata':Float(asdecimal=True)\\n })).fetchall()[0]\\n eq_([type(x) for x in row], [int, float, float, float, decimal.Decimal])\\n eq_(row,\\n (5, 45.6, 45, 53, decimal.Decimal('45.68392'))\\n )\",\n \"def convert_decimal(value: t.Any) -> Decimal:\\n return Decimal(value)\",\n \"def transform_bson(self, value):\\r\\n return value.to_decimal()\",\n \"def transform_bson(self, value):\\r\\n return value.to_decimal()\",\n \"def _serialize_decimal(val):\\n return float(val)\",\n \"def to_python(self, value):\\n if not value or value is models.fields.NOT_PROVIDED:\\n value = None\\n elif not isinstance(value, Decimal):\\n try:\\n value = Decimal(value)\\n except InvalidOperation:\\n value = None\\n return value\",\n \"def addDecimal(self):\\n\\t\\t# set the decimal flag to true\\n\\t\\tself.decimal = True\",\n \"def form_Decimal(request):\\n schema = schemaish.Structure()\\n schema.add('myDecimalField', schemaish.Decimal())\\n form = formish.Form(schema, 'form')\\n return form\",\n \"def decode(val):\\n if isinstance(val, Decimal):\\n return float(val)\\n return val\",\n \"def decimal_default(obj):\\n if isinstance(obj, Decimal):\\n return float(obj)\\n raise TypeError\",\n \"def test_decimal_default(self):\\r\\n default = D('2.00')\\r\\n prop = Decimal(default=default, required=True)\\r\\n self.assertEqual(prop.to_database(None), prop.to_database(default))\",\n \"def isdecimal(self):\\n return isdecimal(self)\",\n \"def d(val, *args, **kwargs):\\n if not isinstance(val, Decimal):\\n val_str = unicode(val)\\n val_d = Decimal(val_str, *args, **kwargs)\\n else:\\n val_d = val\\n return val_d\",\n \"def is_decimal(obj):\\n\\n return isinstance(obj, Decimal)\",\n \"def test_normal_decimal_input(self):\\r\\n ws_leader = \\\"S. O'Neal (14.9)\\\"\\r\\n res = treat_input(ws_leader, type=\\\"float\\\")\\r\\n assert res == 14.9\",\n \"def test_decimal_update(self):\\r\\n vm = Decimal.value_manager(None, None, D('5.00'))\\r\\n assert not vm.changed\\r\\n vm.value = D('4.00')\\r\\n assert vm.changed\",\n \"def decimal(self, column, length=17, precision=6, nullable=False):\\n self._last_column = self.table.add_column(\\n column, \\\"decimal\\\", length=(length, precision), nullable=nullable\\n )\\n return self\",\n \"def _validate_decimal(d: decimal.Decimal, precision: int, scale: int) -> None:\\n _, digits, exp = d.as_tuple()\\n # Precision represents the number of digits that can be stored.\\n if len(digits) > precision:\\n raise ValueError(\\n \\\"decimal value has more digits than is legal according \\\"\\n + \\\"to the schema's precision\\\"\\n )\\n\\n # Scale represents the number of digits held after the decimal point.\\n if exp < 0:\\n if -exp > scale:\\n raise ValueError(\\n \\\"decimal value requires greater decimal scale than is \\\"\\n + \\\"legal according to the schema\\\"\\n )\",\n \"def _repr_(self):\\n return \\\"Complex Field with %s bits of precision\\\"%self._prec\",\n \"def test_decimal_inplace_update(self):\\r\\n vm = Decimal.value_manager(None, None, D('5.00'))\\r\\n assert not vm.changed\\r\\n vm.value += D('1.00')\\r\\n assert vm.changed\",\n \"def test_cast_non_numeric_true():\\n assert _currency_column_to_numeric(\\\"foo\\\", {\\\"foo\\\": 42}) == 42\",\n \"def adapt_decimal(value: t.Any) -> str:\\n return str(value)\",\n \"async def test_decimal_field(database_url):\\n\\n async with Database(database_url) as database:\\n async with database.transaction(force_rollback=True):\\n price = decimal.Decimal(\\\"0.700000000000001\\\")\\n\\n # execute()\\n query = prices.insert()\\n values = {\\\"price\\\": price}\\n await database.execute(query, values)\\n\\n # fetch_all()\\n query = prices.select()\\n results = await database.fetch_all(query=query)\\n assert len(results) == 1\\n if database_url.startswith(\\\"sqlite\\\"):\\n # aiosqlite does not support native decimals --> a roud-off error is expected\\n assert results[0][\\\"price\\\"] == pytest.approx(price)\\n else:\\n assert results[0][\\\"price\\\"] == price\",\n \"def complex_value(self) -> global___Expression.ComplexValue:\",\n \"def to_prec(self, prec):\\n return ComplexField(prec)\",\n \"def get_decimal(self):\\n return self.decimal\",\n \"def testSetPowerWithFloat(self):\\n self.node.power = 100.1\\n\\n self.assertEqual(\\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\\n self.node.power\\n )\",\n \"def isdecimal(a): \\n if not _is_unicode(a):\\n raise TypeError(\\n \\\"isdecimal is only available for Unicode strings and arrays\\\")\\n return _vec_string(a, bool_, 'isdecimal')\",\n \"def test_numeric(self):\\n conn = self.database.connection()\\n cursor = conn.cursor()\\n dialect = self.database.dialect()\\n dbapi = self.database.dbapi()\\n query = dialect.translate('DROP TABLE test_numeric')\\n try:\\n cursor.execute(query)\\n except dbapi.Error:\\n conn.rollback()\\n query = dialect.translate('CREATE TABLE test_numeric ' \\\\\\n '( value NUMERIC(100,50) NOT NULL )')\\n cursor.execute(query)\\n data = []\\n query = 'INSERT INTO test_numeric VALUES (%s)'\\n for i in range(100):\\n int = random.getrandbits(150)\\n frac = random.getrandbits(150)\\n item = decimal.Decimal('%d.%s' % (int, frac))\\n data.append(item)\\n cursor.execute(query, (item,))\\n query = 'SELECT * FROM test_numeric'\\n cursor.execute(query)\\n result = cursor.fetchall()\\n for row in result:\\n item = row[0]\\n assert isinstance(item, decimal.Decimal)\\n assert item in data\\n data.remove(item)\\n query = dialect.translate('DELETE FROM test_numeric')\\n cursor.execute(query)\\n query = dialect.translate('DROP TABLE test_numeric')\\n cursor.execute(query)\\n conn.commit()\",\n \"def foreign_translate(object):\\n if object == None:\\n return Null\\n if isinstance(object, (int, long, float)):\\n return Decimal(object)\\n return object\",\n \"def get_column_type(cls, **kwargs: Any) -> Any:\\n precision = kwargs.get(\\\"precision\\\")\\n scale = kwargs.get(\\\"scale\\\")\\n return sqlalchemy.DECIMAL(precision=precision, scale=scale)\",\n \"def test_double_precision(self):\\n conn = self.database.connection()\\n cursor = conn.cursor()\\n dialect = self.database.dialect()\\n dbapi = self.database.dbapi()\\n query = dialect.translate('DROP TABLE test_double_precision')\\n try:\\n cursor.execute(query)\\n except dbapi.Error:\\n conn.rollback()\\n query = dialect.translate('CREATE TABLE test_double_precision ' \\\\\\n '( value DOUBLE PRECISION NOT NULL )')\\n cursor.execute(query)\\n data = []\\n query = 'INSERT INTO test_double_precision VALUES (%s)'\\n for i in range(100):\\n item = random.random()\\n data.append(item)\\n cursor.execute(query, (item,))\\n query = 'SELECT * FROM test_double_precision'\\n cursor.execute(query)\\n result = cursor.fetchall()\\n for row in result:\\n item = row[0]\\n assert isinstance(item, float)\\n for i,f in enumerate(data):\\n if abs(f - item) < 1e-12:\\n break\\n else:\\n assert False, 'Item not found'\\n query = dialect.translate('DELETE FROM test_double_precision')\\n cursor.execute(query)\\n query = dialect.translate('DROP TABLE test_double_precision')\\n cursor.execute(query)\\n conn.commit()\",\n \"def cast(elem, psql_type):\\n if psql_type == 'real':\\n return float(format(elem, '.6g'))\\n elif psql_type == 'double precision':\\n return float(format(elem, '.15g'))\\n elif psql_type == 'timestamp':\\n if isinstance(elem, pd.Timestamp):\\n return elem.to_pydatetime()\\n else:\\n return elem\\n elif psql_type == 'text':\\n if type(elem) == float:\\n return \\\"NaN\\\"\\n return str(elem)\\n else:\\n return elem\",\n \"def test_float():\\n floatify = fields.FloatField().adapt\\n\\n for input, expect in [\\n (1.1, 1.1),\\n (11, 11.0),\\n (int(5.7), 5)\\n ]:\\n assert floatify(input) == expect\",\n \"def default(self, o):\\n if isinstance(o, Decimal):\\n return float(o)\\n return super(DecimalJSONEncoder, self).default(o)\",\n \"def str_to_decimal(self, decimal_str, key, enforce_row_break=False):\\n\\n break_err = False\\n break_err_msg = \\\"\\\"\\n\\n try:\\n decimal_value = Decimal(decimal_str) \\n except Exception as err:\\n\\n if key == \\\"Payment Amount\\\" and decimal_str == \\\"\\\":\\n decimal_value = None \\n\\n elif enforce_row_break: # assign none to value and generate error \\n decimal_value = None\\n\\n\\n break_err = True\\n break_err_msg = \\\"Couldn't convert %s to decimal\\\" % key\\n\\n # add corresponding error for the row\\n self.update_row_err(break_err, break_err_msg)\\n\\n else:\\n decimal_value = 0.00 # assign 0.00 to decimal value\\\"\\\"\\\"\\n \\n return decimal_value\",\n \"def test_format_nested_fields() -> None:\\n value: Decimal = Decimal(\\\"12.34567\\\")\\n width: int = 10\\n precision: int = 5\\n assert f\\\"result: {value:{width}.{precision}}\\\" == \\\"result: 12.346\\\"\",\n \"def test_float():\\n assert float(Quantity(1, unit('m'))) == float(1)\",\n \"def add_support_for_floats_to_dynamodb():\\n\\n # Ignore loss of precision rather than raising exception\\n DYNAMODB_CONTEXT.clear_traps()\\n\\n # Keep a reference to the original serialization methods\\n boto3_serialize_orig = TypeSerializer.serialize\\n boto3_deserialize_orig = TypeDeserializer.deserialize\\n\\n # Wrap serialization methods to support floats\\n def boto3_serialize(self, value):\\n if isinstance(value, float):\\n value = Decimal(value)\\n return boto3_serialize_orig(self, value)\\n\\n def boto3_deserialize(self, value):\\n value = boto3_deserialize_orig(self, value)\\n if isinstance(value, Decimal):\\n value = float(value)\\n return value\\n\\n # Replace the serialization methods with wrapped versions\\n TypeSerializer.serialize = boto3_serialize\\n TypeDeserializer.deserialize = boto3_deserialize\",\n \"def _assert_valid_value_and_cast(value):\\n if isinstance(value, float):\\n return float_to_decimal(value)\\n if isinstance(value, int):\\n return Decimal(value)\\n if isinstance(value, Decimal):\\n return value\\n\\n raise AssertionError(\\\"{0} is not a valid numeric type.\\\".\\n format(value))\",\n \"def transform_python(self, value):\\r\\n return Decimal128(value)\",\n \"def transform_python(self, value):\\r\\n return Decimal128(value)\",\n \"def test_cast_non_numeric_false():\\n assert _currency_column_to_numeric(\\\"10 dollars\\\", {\\\"foo\\\": 42}) == \\\"10\\\"\",\n \"def ijson_decimal_to_float(event):\\n if event[1] == 'number' and isinstance(event[2], decimal.Decimal):\\n return event[0], event[1], float(event[2])\\n else:\\n return event\",\n \"def EvaluateFields(self, *float, **kwargs):\\n ...\",\n \"def test_prepare_value_limit_denominator(self):\\n field = DecimalFractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def testSatBecomesDecimal(self):\\n sat = 3\\n\\n self.cc.sat = sat\\n\\n self.assertEqual(\\n Decimal(sat),\\n self.cc.sat\\n )\",\n \"def _cast_to_number(self, key):\\n q = DBSession.query(cast(self.db_value.value, Float)). \\\\\\n join(self.db_tag). \\\\\\n join(self.db_key). \\\\\\n filter(self.db_key.key == key)\\n try:\\n q.all()\\n return True\\n except:\\n return False\",\n \"def num(value):\\n value = Decimal(value)\\n return value\",\n \"def to_float_complex(self):\\r\\n return eval(str(self))\",\n \"def test_calculate_retention_fee():\\n assert calculate_retention_fee(2578) == Decimal('128.91')\",\n \"def testSetWithFloat(self):\\n self.node.sat = 100.1\\n\\n self.assertEqual(\\n Decimal('100.1'),\\n self.node.sat\\n )\",\n \"def _real_field(self):\\n try:\\n return self.__real_field\\n except AttributeError:\\n from .real_mpfr import RealField\\n self.__real_field = RealField(self._prec)\\n return self.__real_field\",\n \"def adapt_decimalfield_value(self, value, max_digits=None, decimal_places=None):\\n strvalue = super().adapt_decimalfield_value(value, max_digits, decimal_places)\\n return Decimal(strvalue)\",\n \"def __float__(self):\\n return float(self.number)\",\n \"def _(primitive_type: DecimalType, value: Decimal) -> bytes:\\n _, digits, exponent = value.as_tuple()\\n exponent = abs(int(exponent))\\n if exponent != primitive_type.scale:\\n raise ValueError(f\\\"Cannot serialize value, scale of value does not match type {primitive_type}: {exponent}\\\")\\n elif len(digits) > primitive_type.precision:\\n raise ValueError(\\n f\\\"Cannot serialize value, precision of value is greater than precision of type {primitive_type}: {len(digits)}\\\"\\n )\\n\\n return decimal_to_bytes(value)\",\n \"def test_vat_float(self):\\n value = 412.32\\n self.assertAlmostEqual(cr.vat(value), value * 0.15, places=2)\",\n \"def __float__( self ):\\r\\n\\t\\tif ( types.ComplexType in ( type( self.numerator ), type( self.denominator ) ) ):\\r\\n\\t\\t\\tn,d = self.numerator, self.denominator\\r\\n\\t\\t\\tif ( type( n ) == types.ComplexType ): n = abs( n )\\r\\n\\t\\t\\tif ( type( d ) == types.ComplexType ): d = abs( d )\\r\\n\\t\\t\\treturn n / d\\r\\n\\t\\treturn float( self.numerator ) / self.denominator\",\n \"def float_format(self):\\n ...\",\n \"def validate_decimal(v: str, field: Field):\\n field_info = field.field_info\\n inclusive = field_info.ge is not None or field_info.le is not None\\n min_value = field_info.gt if field_info.gt is not None else field_info.ge\\n min_value = Decimal(min_value) if min_value is not None else min_value\\n max_value = field_info.lt if field_info.lt is not None else field_info.le\\n max_value = Decimal(max_value) if max_value is not None else max_value\\n ret = validate_decimal(v, min_value, max_value, inclusive)\\n if ret is not None:\\n raise ValueError(ret)\\n return v\",\n \"def __new__(self, *args, **kwargs):\\n if not self._precision is None:\\n if len(args):\\n value = Decimal(args[0]).quantize(Decimal(str(self._precision)))\\n else:\\n value = Decimal(0)\\n elif len(args):\\n value = Decimal(args[0])\\n else:\\n value = Decimal(0)\\n obj = Decimal.__new__(self, value, **kwargs)\\n return obj\",\n \"def Ro_decimal_constr(x_par):\\n if len(x_par) == 3:\\n return x_par[0] * x_par[2] / x_par[1]\\n else:\\n return x_par[0] / x_par[1]\",\n \"def convert_dollars(df,col_name):\\n df[col_name] = df[col_name].replace('[^.0-9]','',regex=True).astype(float)\\n return df\",\n \"def arrow_type_for(column_name, cx_oracle_type, precision, scale):\\n\\n # In the schema, these are bare NUMBER columns, so erroneously come back as floats.\\n if column_name in ['AVPID', 'TUMOUR_AVPID']:\\n return pa.int64()\\n\\n if cx_oracle_type == cx_Oracle.DB_TYPE_NUMBER:\\n if scale == 0:\\n if precision == 1:\\n return pa.bool_()\\n else:\\n return pa.int64()\\n else:\\n return pa.float64()\\n else:\\n return type_map.get(cx_oracle_type)\",\n \"def RestrictedPrecisionDecimalType(*args, **kwargs):\\n precision = kwargs.pop(\\\"precision\\\", False)\\n class RestrictedPrecisionDecimal(Decimal):\\n \\\"\\\"\\\"\\n Class extending decimal.Decimal to restrict the precision that is\\n stored, supporting the fraction-digits argument of the YANG decimal64\\n type.\\n \\\"\\\"\\\"\\n _precision = 10.0**(-1.0*int(precision))\\n def __new__(self, *args, **kwargs):\\n \\\"\\\"\\\"\\n Overloads the decimal __new__ function in order to round the input\\n value to the new value.\\n \\\"\\\"\\\"\\n if not self._precision is None:\\n if len(args):\\n value = Decimal(args[0]).quantize(Decimal(str(self._precision)))\\n else:\\n value = Decimal(0)\\n elif len(args):\\n value = Decimal(args[0])\\n else:\\n value = Decimal(0)\\n obj = Decimal.__new__(self, value, **kwargs)\\n return obj\\n return type(RestrictedPrecisionDecimal(*args, **kwargs))\",\n \"def somme(self) -> Numeric:\\n return query_sum(\\n self.offre_set.filter(valide=True),\\n \\\"prix\\\",\\n output_field=models.DecimalField(),\\n )\",\n \"def test_prepare_value_int(self):\\n field = DecimalFractionField()\\n result = field.prepare_value(1)\\n self.assertEqual(\\\"1\\\", result)\",\n \"def conform_input_data(rowdict):\\n # rowdict['Value'] = float(rowdict['Value'])\\n rowdict['TimeStamp'] = TS_to_date(rowdict['TimeStamp'][:19])\\n for floatcolumn in ['LowPx','OpenPx','ClosePx','QuoteCount','HighPx','TradeCount']:\\n if floatcolumn in rowdict:\\n rowdict[floatcolumn] = float(rowdict[floatcolumn])\\n return rowdict\",\n \"def test_convert_amounts(self):\\n pass\",\n \"def get_float2(self):\\n pass\",\n \"def test_non_cast_input():\\n assert _currency_column_to_numeric(\\\"-1,000,000 yen\\\") == \\\"-1000000\\\"\",\n \"def test_many_decimal_data_points(self):\\r\\n values = [3.14, 42, 2.718281, 1.41421, 10]\\r\\n expect_mean_result = 11.854498\\r\\n expected_sd_result = 15.36621\\r\\n result = multipoint_mean_sd(values)\\r\\n\\r\\n self.assertAlmostEqual(expect_mean_result, result['mean_result'], 4)\\r\\n self.assertAlmostEqual(expected_sd_result, result['sd_result'], 4)\",\n \"def from_RealField(K1, a, K0):\\n p, q = K0.to_rational(a)\\n\\n if q == 1:\\n return K1.dtype(K1.dom.dtype(p))\",\n \"def monetary_amount_valid(record, field_name='price', min=1, max=10):\\n monetary_amount = record[field_name]\\n assert isinstance(monetary_amount, float)\\n string_price = str(monetary_amount)\\n decimal = string_price.split(\\\".\\\")[1]\\n assert min <= monetary_amount <= max and len(decimal) <= 2\",\n \"def _convert_to_decimal(value):\\n d0 = value[0][0]\\n d1 = value[0][1]\\n d = float(d0) / float(d1)\\n \\n m0 = value[1][0]\\n m1 = value[1][1]\\n m = float(m0) / float(m1)\\n \\n s0 = value[2][0]\\n s1 = value[2][1]\\n s = float(s0) / float(s1)\\n \\n return d + (m / 60.0) + (s / 3600.0)\",\n \"def default(self, o: Decimal) -> Union[int, float]:\\n if isinstance(o, Decimal):\\n # NOTE: The below is potentially a HUGE MISTAKE and an\\n # unnecessary OVER ENGINEERING! but this works. This is\\n # not required as such because we can get around this by\\n # converting everything to float by default but it makes\\n # more sense to return response of ints as int and float as\\n # float.\\n return int(o) if float(o).is_integer() else float(o)\\n return super().default(o)\",\n \"def test_prepare_value_limit_denominator(self):\\n field = FractionField(limit_denominator=3)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\",\n \"def __to_value(self, s):\\r\\n if isinstance(s, list):\\r\\n s = s[0]\\r\\n if s is None:\\r\\n return None\\r\\n elif s.strip() == '':\\r\\n return None\\r\\n else:\\r\\n return Decimal(s)\",\n \"def validate_insert(self, s, internal=True):\\n super(FieldNumeric, self).validate_insert(s, internal) # mandatory check\\n if s:\\n try:\\n float(s)\\n except:\\n raise FilemanError(\\\"\\\"\\\"[%s] is not a valid number\\\"\\\"\\\" % s)\",\n \"def normalisePrice(raw):\\n if raw:\\n return Decimal(str(raw)).to_eng_string()\\n else:\\n return None\",\n \"def is_qty_decimal(self):\\n return self._is_qty_decimal\",\n \"def test_double_default(self):\\r\\n default = 7.0\\r\\n prop = Double(default=default, required=True)\\r\\n self.assertEqual(prop.to_database(None), prop.to_database(default))\",\n \"def __round__(self, ???):\",\n \"def testSetSlopeWithFloat(self):\\n self.node.slope = 100.1\\n\\n self.assertEqual(\\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\\n self.node.slope\\n )\",\n \"def somme(self) -> Numeric:\\n return query_sum(self.offres(), \\\"prix\\\", output_field=models.DecimalField())\",\n \"def __float__(self) -> float:\\n return self._translate_in_type(float, self.integer)\",\n \"def test_prepare_value_coerce_thirds(self):\\n field = DecimalFractionField(coerce_thirds=True)\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\\n\\n result = field.prepare_value(Decimal(1 / 3.0))\\n self.assertEqual(\\\"1/3\\\", result)\\n\\n result = field.prepare_value(Decimal(2 / 3.0))\\n self.assertEqual(\\\"2/3\\\", result)\\n\\n result = field.prepare_value(Decimal(2 / 6.0))\\n self.assertEqual(\\\"1/3\\\", result)\\n\\n result = field.prepare_value(Decimal(4 / 6.0))\\n self.assertEqual(\\\"2/3\\\", result)\\n\\n result = field.prepare_value(Decimal(4 / 3.0))\\n self.assertEqual(\\\"1 1/3\\\", result)\\n\\n result = field.prepare_value(Decimal(5 / 3.0))\\n self.assertEqual(\\\"1 2/3\\\", result)\",\n \"def convert_types(cls, value):\\n if type(value) in (datetime, date):\\n return time.mktime(value.timetuple())\\n elif isinstance(value, Decimal):\\n return float(value)\\n else:\\n return value\",\n \"def validate(cls, **kwargs: Any) -> None:\\n precision = kwargs.get(\\\"precision\\\")\\n scale = kwargs.get(\\\"scale\\\")\\n if precision is None or precision < 0 or scale is None or scale < 0:\\n raise ModelDefinitionError(\\n \\\"Parameters scale and precision are required for field Decimal\\\"\\n )\",\n \"def get_column_type(cls, **kwargs: Any) -> Any:\\n return sqlalchemy.Float()\",\n \"def getDouble(self, int: int, int2: int) -> float:\\n ...\",\n \"def _get_number(self):\\n return Decimal(str(self)[1:])\",\n \"def test_calculate_base_monthly_payment():\\n assert calculate_base_monthly_payment(2578, 5) == Decimal('489.82')\",\n \"def get_real(val, precision):\\n if precision == \\\"single\\\":\\n return numpy.float32(val)\\n elif precision == \\\"double\\\":\\n return numpy.float64(val)\\n else:\\n raise ValueError (\\\"precision %s not supported!\\\"%(precision))\",\n \"def real_float_to_decimal_cast_cases(float_ty, max_precision):\\n mantissa_digits = 16\\n for precision in range(1, max_precision, 3):\\n for scale in range(0, precision, 2):\\n epsilon = 2 * 10**max(precision - mantissa_digits, 0)\\n abs_minval = largest_scaled_float_not_above(epsilon, scale)\\n abs_maxval = largest_scaled_float_not_above(\\n 10**precision - epsilon, scale)\\n yield FloatToDecimalCase(precision, scale, abs_minval)\\n yield FloatToDecimalCase(precision, scale, abs_maxval)\",\n \"def __float__(self):\\n return self.num / self.denom # result of / is of type float\",\n \"def convert(self, value):\\n return self.ASCIIToDecimal(value)\",\n \"def testPowerDefault(self):\\n self.assertEqual(\\n (Decimal('1.0'), Decimal('1.0'), Decimal('1.0')),\\n self.node.power\\n )\",\n \"def testSetOffsetWithFloat(self):\\n self.node.offset = 100.1\\n\\n self.assertEqual(\\n (Decimal('100.1'), Decimal('100.1'), Decimal('100.1')),\\n self.node.offset\\n )\",\n \"def to_numerical(table, column_name):\\n def replace(entry):\\n return float(entry)\\n assert (isinstance(table, Table)), \\\"Input not a supported type.\\\"\\n column = table.apply(replace, column_name)\\n return table.append_column(column_name, column)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7193939","0.6367631","0.62804735","0.61756307","0.61756307","0.5980316","0.59415334","0.58247906","0.58159804","0.58049774","0.57988","0.57257456","0.57224286","0.5637044","0.5616838","0.5612793","0.5556482","0.5542215","0.5521639","0.54359597","0.540146","0.5389036","0.5378906","0.5355483","0.53428376","0.5331299","0.5319867","0.5308608","0.52483803","0.52477616","0.5236403","0.52347225","0.520928","0.51999944","0.5192901","0.51916355","0.5187969","0.51867276","0.51864225","0.51607466","0.51502967","0.5134362","0.5134362","0.51183033","0.51167053","0.51128066","0.5105629","0.51032937","0.5096602","0.509127","0.50873977","0.50759923","0.50736094","0.50674325","0.50663865","0.5058639","0.5049701","0.504781","0.50393337","0.5035869","0.5032855","0.5031646","0.5031174","0.5024019","0.5016309","0.50127274","0.5011569","0.5006815","0.49940896","0.49807286","0.49766794","0.49758655","0.49701616","0.49363768","0.4927047","0.4916173","0.49077696","0.49029133","0.49029097","0.48954773","0.489303","0.48894158","0.4884532","0.48789707","0.4875348","0.48750997","0.48727354","0.4867068","0.48664737","0.4866406","0.48515105","0.48513064","0.4845861","0.48442957","0.48438698","0.48418653","0.4840647","0.48353297","0.48336738","0.483073","0.48184273"],"string":"[\n \"0.7193939\",\n \"0.6367631\",\n \"0.62804735\",\n \"0.61756307\",\n \"0.61756307\",\n \"0.5980316\",\n \"0.59415334\",\n \"0.58247906\",\n \"0.58159804\",\n \"0.58049774\",\n \"0.57988\",\n \"0.57257456\",\n \"0.57224286\",\n \"0.5637044\",\n \"0.5616838\",\n \"0.5612793\",\n \"0.5556482\",\n \"0.5542215\",\n \"0.5521639\",\n \"0.54359597\",\n \"0.540146\",\n \"0.5389036\",\n \"0.5378906\",\n \"0.5355483\",\n \"0.53428376\",\n \"0.5331299\",\n \"0.5319867\",\n \"0.5308608\",\n \"0.52483803\",\n \"0.52477616\",\n \"0.5236403\",\n \"0.52347225\",\n \"0.520928\",\n \"0.51999944\",\n \"0.5192901\",\n \"0.51916355\",\n \"0.5187969\",\n \"0.51867276\",\n \"0.51864225\",\n \"0.51607466\",\n \"0.51502967\",\n \"0.5134362\",\n \"0.5134362\",\n \"0.51183033\",\n \"0.51167053\",\n \"0.51128066\",\n \"0.5105629\",\n \"0.51032937\",\n \"0.5096602\",\n \"0.509127\",\n \"0.50873977\",\n \"0.50759923\",\n \"0.50736094\",\n \"0.50674325\",\n \"0.50663865\",\n \"0.5058639\",\n \"0.5049701\",\n \"0.504781\",\n \"0.50393337\",\n \"0.5035869\",\n \"0.5032855\",\n \"0.5031646\",\n \"0.5031174\",\n \"0.5024019\",\n \"0.5016309\",\n \"0.50127274\",\n \"0.5011569\",\n \"0.5006815\",\n \"0.49940896\",\n \"0.49807286\",\n \"0.49766794\",\n \"0.49758655\",\n \"0.49701616\",\n \"0.49363768\",\n \"0.4927047\",\n \"0.4916173\",\n \"0.49077696\",\n \"0.49029133\",\n \"0.49029097\",\n \"0.48954773\",\n \"0.489303\",\n \"0.48894158\",\n \"0.4884532\",\n \"0.48789707\",\n \"0.4875348\",\n \"0.48750997\",\n \"0.48727354\",\n \"0.4867068\",\n \"0.48664737\",\n \"0.4866406\",\n \"0.48515105\",\n \"0.48513064\",\n \"0.4845861\",\n \"0.48442957\",\n \"0.48438698\",\n \"0.48418653\",\n \"0.4840647\",\n \"0.48353297\",\n \"0.48336738\",\n \"0.483073\",\n \"0.48184273\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":20197,"cells":{"query":{"kind":"string","value":"MS Access doesn't create databases."},"document":{"kind":"string","value":"def create_db(self):\n return None"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def create_db():\n db.create_all()\n click.echo(\"DB criado com sucesso!\")","def create_db():\n db.create_all()\n print(\"DB Created\")","def create_db():\n db.create_all()\n click.echo(\"Banco de dados criado\")","def create_new_db():\n global data_base, table\n data_base = asksaveasfilename(title=\"Select file\", filetypes=((\"DATA BASE\", \"*.db\"), (\"all files\", \"*.*\")),\n defaultextension='.db')\n\n if Path(data_base).suffix == '.db':\n create_win_create_table()\n else:\n mistake_db_file()","def create_db(self):","def create_db():\n db.create_all()\n print('Database structure created successfully')","def create():\n\tcreate_db()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create_db():\n db.create_all()","def create(name):\n\t\treturn \"CREATE DATABASE {0};\".format(name)","def create_database_stock_master():\n sql = \"\"\"\n CREATE DATABASE stock_master;\n \"\"\"\n excute_sql(sql,None)","def _create_db(db_name):\n template_conn.execute('commit')\n template_conn.execute('create database {}'.format(db_name))","def create_database():\n try:\n db.create_all()\n print('Created tables successfully!')\n except Exception:\n print('Failed to create db. Make sure your database server is running')","def create_db():\n db.create_all()\n print ('Intialized....!')","def create_db(self, db_name):\n if self.conf['database'] not in self.show_database():\n sql = 'CREATE DATABASE IF NOT EXISTS %s CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % db_name\n Log.debug('DB -> %s' % sql)\n self.execute(sql)","def create_db():\n from sqlalchemy_utils import database_exists, create_database, drop_database\n if not database_exists(DB_URL):\n print('Creating database.')\n create_database(DB_URL)\n else:\n drop_database(DB_URL)\n create_database(DB_URL)\n print(\"Deleted and created new database\")\n create_tables()","def createDb():\n db.drop_all()\n db.create_all()","def make_db():\n\n db.create_all()","def _create_db(self):\n self.db = easydms.dbcore.Database(\":memory:\")\n self.db.create_db()","def create_db(self):\n creation_query = f\"CREATE DATABASE {DB_NAME} CHARACTER SET 'utf8mb4' \"\n existence_query = f\"USE {DB_NAME}\"\n try:\n self.cursor.execute(creation_query)\n self.cursor.execute(existence_query)\n print(f\"\\n La base de données |{DB_NAME}| a été créée \\n\")\n except:\n print(\"\\n Une erreur s'est produite lors \"\n \"de la création de la base de données \\n\")","def create_database():\n create_db(app)","def createdb(dbname):\n os.system(\"createdb -w %s\" % dbname)","def newDb(options, dbName, adminPswd, userPswd, viewerPswd):\n if not re.match(\"^[A-Za-z][A-Za-z0-9_]*$\", dbName):\n errorPrint(\"'%s' is not a valid database name\" % dbName)\n return\n\n adminName = dbName + \"_admin\"\n userName = dbName + \"_user\"\n viewerName = dbName + \"_viewer\"\n\n setupDictionaryDatabases(options, {\n 'databases': {\n dbName: {\n 'ownerRole': adminName,\n 'roles': {\n adminName: {\n 'password': adminPswd,\n 'role': 'admin'\n },\n userName: {\n 'password': userPswd,\n 'role': 'writer'\n },\n viewerName: {\n 'password': viewerPswd,\n 'role': 'reader'\n }\n }\n }\n }\n })","def createDB(dbname='ddsassignment3'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n print \"Count \",count\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print 'A database named {0} already exists'.format(dbname)\n\n # Clean up\n cur.close()\n con.commit()\n con.close()","def create_db():\n _init_db()\n db.create_all()","def createDB(dbname='ddsassignment3'):\r\n # Connect to the default database\r\n con = getOpenConnection(dbname='postgres')\r\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\r\n cur = con.cursor()\r\n\r\n # Check if an existing database with the same name exists\r\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\r\n count = cur.fetchone()[0]\r\n if count == 0:\r\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\r\n else:\r\n print 'A database named {0} already exists'.format(dbname)\r\n\r\n # Clean up\r\n cur.close()\r\n con.commit()\r\n con.close()","def setupDatabases(self):\n param = self.getDefaultDatabaseConnectionParameter()\n db = DatabaseFactory.getDatabase(self.defaultDriver(), {})\n db.createDatabase(param)\n db.connect(param)\n if db.isConnected():\n self.settingsDb = db\n db.createObservations()\n db.createSensors()\n else:\n return False\n # replace by settings validation method later\n return self.check()","def create_db():\n db_url = engine.url\n if not database_exists(db_url):\n create_database(db_url)\n base.metadata.create_all()","def makeDatabase(con, options, dbName, dbOwnerRole, dbInfo, dbRoles):\n ownerRole = dbInfo[\"ownerRole\"]\n userRole = \"{0}_common_user_role\".format(dbName)\n viewerRole = \"{0}_common_viewer_role\".format(dbName)\n \n optionalDbExecute(con, options, \"CREATE ROLE {0}\".format(userRole))\n optionalDbExecute(con, options, \"CREATE ROLE {0}\".format(viewerRole))\n\n trace(\"Creating database %s with owner '%s'\" % (dbName, ownerRole))\n optionalDbExecute(con, options, \"CREATE DATABASE %s WITH OWNER %s\" % (dbName, ownerRole))\n con2 = None\n try:\n con2 = dbConnect(database = dbName, user = options[\"dbuser\"], password = options[\"dbpassword\"], host = options[\"dbhost\"])\n\n optionalDbExecute(con2, options, \"REVOKE ALL on DATABASE {0} FROM {1}\".format(dbName, viewerRole))\n optionalDbExecute(con2, options, \"REVOKE ALL on DATABASE {0} FROM {1}\".format(dbName, userRole))\n for name in dbRoles:\n userInfo = dbRoles[name]\n if userInfo[\"role\"] == \"writer\" or userInfo[\"role\"] == \"reader\":\n optionalDbExecute(con2, options, \"REVOKE ALL on DATABASE {0} FROM {1}\".format(dbName, name))\n\n # user can do everything viewer can\n optionalDbExecute(con2, options, \"GRANT {0} TO {1}\".format(viewerRole, userRole))\n # admin can do everything user and viewer can\n optionalDbExecute(con2, options, \"GRANT {0} TO {1}\".format(userRole, ownerRole))\n\n # viewer, user, admin can connect\n optionalDbExecute(con2, options, \"GRANT CONNECT ON DATABASE {0} TO {1}\".format(dbName, viewerRole))\n\n # create a schema we can optionally use *\n schemaName = \"{0}_db_common\".format(dbName)\n optionalDbExecute(con2, options, \"CREATE SCHEMA if not exists {0} AUTHORIZATION {1}\".format(schemaName, ownerRole))\n\n # search_path is not inherited, so set it here\n for role in [ ownerRole, userRole, viewerRole ]:\n optionalDbExecute(con2, options, \"ALTER ROLE {1} IN DATABASE {0} SET search_path = public, {2}\".format(dbName, role, schemaName))\n\n # viewer,user can select from schema\n optionalDbExecute(con2, options, \"GRANT USAGE ON SCHEMA {0} TO {1}\".format(schemaName, viewerRole))\n # admin can create on schema\n optionalDbExecute(con2, options, \"GRANT CREATE ON SCHEMA {0} TO {1}\".format(schemaName, ownerRole))\n\n # viewer, user, admin can select on tables\n optionalDbExecute(con2, options, \"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT SELECT ON TABLES TO {0}\".format(viewerRole, ownerRole))\n # user, admin can ins/upd/del/tru on tables\n optionalDbExecute(con2, options, \"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT INSERT, UPDATE, DELETE, TRUNCATE ON TABLES TO {0}\".format(userRole, ownerRole))\n # user, admin can update on sequences\n optionalDbExecute(con2, options, \"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT USAGE, SELECT, UPDATE ON SEQUENCES TO {0}\".format(userRole, ownerRole))\n\n # user, admin can create temp tables\n optionalDbExecute(con2, options, \"GRANT TEMP ON DATABASE {0} TO {1}\".format(dbName, userRole))\n\n for name in dbRoles:\n userInfo = dbRoles[name]\n if userInfo[\"role\"] == \"writer\":\n optionalDbExecute(con2, options, \"GRANT {0} TO {1}\".format(userRole, name))\n elif userInfo[\"role\"] == \"reader\":\n optionalDbExecute(con2, options, \"GRANT {0} TO {1}\".format(viewerRole, name))\n\n # search_path is not inherited, so set it here\n optionalDbExecute(con2, options, \"ALTER ROLE {1} IN DATABASE {0} SET search_path = public, {2}\".format(dbName, name, schemaName))\n\n except psycopg2.DatabaseError as e:\n die('Error %s' % e)\n\n finally:\n if con2:\n con2.commit()\n con2.close()","def test_create_database(self):\n self.assertTrue(self.ss.create_database(self.test_database),\n \"Create testing database\")\n self.assertTrue(os.path.exists(self.test_database))\n self.assertNotEqual(self.test_database, self.ss.data_file(),\n \"Should not connect to created database\")","def createdb():\n db.create_all()","def create_database():\n with connection:\n connection.execute(CREATE_MOVIE_TABLE)\n connection.execute(CREATE_USER_TABLE)\n connection.execute(CREATE_WATCHED_TABLE)","def database(name, **kwargs):\n if not database_exists(name, **kwargs):\n create_database(name, **kwargs)","def initdb():\n db.create_all()","def initdb():\n db.create_all()","def createDB(dbname='ddsassignment3'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print 'A database named {0} already exists'.format(dbname)\n\n # Clean up\n cur.close()\n con.commit()\n con.close()","def __KCreateDB(self):\n if self.create_db_method == \"Create New\":\n if self.page_size == \"Default\":\n createCommand = \"CREATE DATABASE '%s' USER '%s' PASSWORD '%s'\" % (self.__dsn,\n self.user_name,\n self.user_password)\n else:\n createCommand = \"CREATE DATABASE '%s' USER '%s' PASSWORD '%s' PAGE_SIZE=%d\" % (self.__dsn,\n self.user_name,\n self.user_password,\n int(self.page_size))\n try:\n conn= kdb.create_database(createCommand, int(self.sql_dialect))\n\n conn.close()\n\n except:\n self.__result.NoteException(cause=\"Exception raised while creating database.\")\n return","def createDB(dbname='dds_assignment1'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print('A database named {0} already exists'.format(dbname))\n\n # Clean up\n cur.close()\n con.close()","def createdb():\n if database.exists():\n raise click.UsageError(\n click.style('Database already exists at {}.'\n .format(database.url), fg='red')\n )\n else:\n database.create()\n click.echo(OK)","def createDB(dbname='dds_assignment'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print 'A database named {0} already exists'.format(dbname)\n\n # Clean up\n cur.close()\n con.commit()\n con.close()","def create_databases():\n db_connection = connect_to_db()\n\n # Create database tables.\n create_tables(db_connection)\n\n # Populate water tables.\n populate_water_tables(db_connection)\n\n # station_data = get_station_data()\n # station = station_data.query('ŠIFRA == 30301')\n # print(station)\n # index = station.index[0]\n # lat = station.at[index, 'LAT']\n # lng = station.at[index, 'LON']\n # name = f\"{station.at[index, 'VODOMERNA POSTAJA']} ({station.at[index, 'VODOTOK']})\"\n # print(index, lat, lng, name)\n\n # Populate location tables\n # populate_locations(db_connection)\n\n # Populate weather tables\n populate_weather(db_connection)\n\n db_connection.commit()\n db_connection.close()","def createDB(dbname='dds_assignment'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print('A database named ' + dbname + ' already exists')\n\n # Clean up\n cur.close()\n con.close()","def createDB(dbname='dds_assignment'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print 'A database named {0} already exists'.format(dbname)\n\n # Clean up\n cur.close()\n con.close()","def createDB(dbname='dds_assignment'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print 'A database named {0} already exists'.format(dbname)\n\n # Clean up\n cur.close()\n con.close()","def create_empty_db():\r\n drop_db()\r\n database.create_tables([Customer])\r\n database.close()","def createDB(dbname='dds_assignment2'):\n # Connect to the default database\n con = getOpenConnection(dbname='postgres')\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\n cur = con.cursor()\n\n # Check if an existing database with the same name exists\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\n count = cur.fetchone()[0]\n if count == 0:\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\n else:\n print('A database named {0} already exists'.format(dbname))\n\n # Clean up\n cur.close()\n con.commit()\n con.close()","def create_database():\n Base.metadata.create_all(bind=engine)","def new_database(app):\n app.status.message(\"Opening a folder..\")\n path = app.dialog.directory(\"Select a folder for the new database..\")\n if path == '':\n app.status.message('') \n return\n app.status.cursorToHourglass()\n app.close()\n folder = db.database(path=path, \n status = app.status, \n dialog = app.dialog)\n app.display(folder)\n app.status.hide()\n app.status.cursorToNormal()","def create():\n\n from slicr.extensions import db\n\n click.echo('creating database...')\n\n db.create_all()","def create_database():\n # Depending on your local settings, you may need to specify a user and password, e.g.\n # conn = psycopg2.connect(dbname=\"postgres\", user=\"postgres\", password=\"password\")\n conn = psycopg2.connect(dbname=\"postgres\")\n conn.autocommit = True # it seems this mode is needed to make a db\n conn.set_isolation_level(0) # also this for dropping db\n\n # un-comment this line if you already have a database called\n # `opportunity_youth` and you want to drop it\n # execute_sql_script(conn, \"01_drop_old_database.sql\")\n execute_sql_script(conn, \"02_create_new_database.sql\")\n\n conn.close()","def fd_create(db_name):\n # check db exists\n if db_name in (\n FdMultiController.fd_list() + [FdMultiController._db_registry_name]\n ):\n raise Exception(\"DB \" + db_name + \" already exists\")\n try:\n os.remove(FdMultiController._path_generator(db_name))\n except Exception:\n pass\n # create database and read schema\n db_address = FdMultiController._path_generator(db_name)\n conn = None\n try:\n with open(FdMultiController._path_generator(\"dbSchema.sql\")[:-3]) as file:\n conn = sqlite3.connect(db_address)\n curr = conn.cursor()\n curr.executescript(file.read())\n conn.close()\n FdMultiController._add_name(db_name)\n return True\n except Exception:\n # generic class used to account for OS and import exceptions\n return False","def init_db():\n\tdb.drop_all()\n\tdb.create_all()\n\n\tprint(\"Initialized Database.\")\n\treturn","def create_db(drop_first=False):\n\n # if drop_first is True, delete database tables first\n if drop_first:\n db.drop_all()\n db.create_all()\n print(f'[INFO] Created database tables.')","def create_databases(self, overwrite = False):\r\n self.validate_config()\r\n self.template_runner.create_databases(overwrite)","def init_db():\n db.drop_all()\n db.create_all()\n\n print(\"Initialized Connect 4 Database.\")","def setup_database(self):\n self.db.setup_database()","def create_db(num_users=5):\n db.create_all()","def create_prod_db():\n _create_database(is_production=True)","def create_db():\n # check for DB existance\n db_file = vmcheckerpaths.db_file()\n if not os.path.isfile(db_file):\n create_db_tables(db_file)\n else:\n _logger.info('Skipping existing Sqlite3 DB file %s' % db_file)","def create_db(db_name: str = DB_NAME) -> DBConnection:\n connection = open_db(db_name)\n connection.execute(\"\"\"\n CREATE TABLE docs\n (did INTEGER PRIMARY KEY, \n title TEXT NOT NULL, \n url TEXT NOT NULL)\n \"\"\")\n connection.execute(\"\"\"\n CREATE TABLE tfs \n (did INTEGER,\n term TEXT NOT NULL,\n tf INTEGER)\n \"\"\")\n connection.execute(\"\"\"\n CREATE TABLE boost\n (did INTEGER,\n date INTEGER,\n page INTEGER\n )\"\"\")\n print(f\"[+] Created db {DB_NAME}\")\n return connection","def __create_db(self):\n\n if not database_exists(self.db.url):\n create_database(self.db.url)\n print(\"DB Created\")\n\n return \"Does DB exist? {}\".format(database_exists(self.db.url))","def db_createall():\n db.create_all()","def create_DB (name):\n engine = create_engine('sqlite:///%s' % name)\n Base.metadata.create_all(engine)","def test_creation_when_no_database_exists(self):\n database_filename = \"test.db\"\n\n # Delete the test database if it exists.\n test_database = os.path.join(os.getcwd(), database_filename)\n if os.path.exists(test_database):\n os.remove(test_database)\n\n # Create the database object, build the database\n database = app.database.Database(database_filename)\n database.create_database()\n\n # Pull out the table names from the database we've created.\n column_names = extract_column_names(database_filename)\n\n # Assert that they are as expected:\n for column_name in app.database.database_columns:\n self.assertEqual(\n True,\n column_name in column_names,\n \"Database creation process did not yield the column names expected. Missing: {0}\".format(column_name)\n )","def create_db_execute(self):\n self.execute(query=self.db_create_schema.format(self.db_name))","def create_db(self, dbname):\n if dbname not in self.list_dbs():\n return self.put(dbname).text\n else:\n raise ExistingDatabase(dbname)","def createdb():\n print \"here\"\n db.create_all()","def create_db(dbname):\r\n # Connect to the default database\r\n con = getopenconnection(dbname='postgres')\r\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\r\n cur = con.cursor()\r\n\r\n # Check if an existing database with the same name exists\r\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\'%s\\'' % (dbname,))\r\n count = cur.fetchone()[0]\r\n if count == 0:\r\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\r\n else:\r\n print 'A database named {0} already exists'.format(dbname)\r\n\r\n # Clean up\r\n cur.close()\r\n con.close()","def createDataBase(mysql,dbase):\n\tsql = 'CREATE DATABASE IF NOT EXISTS '+ dbase + ';'\n\tmysql.query(sql)\n\tmysql.select_db(dbase)\n\tsql = 'DROP TABLE IF EXISTS names;'\n\tmysql.query(sql)\n\tsql = 'DROP TABLE IF EXISTS files;'\n\tmysql.query(sql)\n\tsql = 'DROP TABLE IF EXISTS linesinfile;'\n\tmysql.query(sql)\n\tsql = 'DROP TABLE IF EXISTS allfiles;'\n\tmysql.query(sql)\n\tsql = 'DROP TABLE IF EXISTS allnames;'\n\tmysql.query(sql)\n\tsql = 'CREATE TABLE names (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\n\tname TINYTEXT NOT NULL);'\n\tmysql.query(sql)\n\tsql = 'CREATE TABLE files (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\n\t\tname BIGINT NOT NULL, \\\n\t\tfilename TEXT NOT NULL \\\n\t\tREFERENCES names(id));'\n\tmysql.query(sql)\n\tsql = 'CREATE TABLE linesinfile (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\n\t\tfilename BIGINT NOT NULL, \\\n\t\tnumber TEXT NOT NULL, \\\n\t\tref TINYTEXT NOT NULL \\\n\t\tREFERENCES files(id));'\n\tmysql.query(sql) \n\tsql = 'CREATE TABLE allfiles (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\n\tfile TEXT NOT NULL);'\n\tmysql.query(sql)\n\tsql = 'CREATE TABLE allnames (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\n\t\tfile BIGINT NOT NULL, \\\n\t\tname TEXT NOT NULL \\\n\t\tREFERENCES allfiles(id));'\n\tmysql.query(sql)","def create_database_future_master():\n sql = \"\"\"\n CREATE DATABASE future_master;\n \"\"\"\n excute_sql(sql, None)","def setdb():\n\n if not database_exists(DB_URL):\n print('Creating database.')\n create_database(DB_URL)\n\n print('Creating tables.')\n db.create_all()\n print('Shiny!')","def db_create():\n db.drop_all()\n db.create_all()\n db.session.commit()","def pgsql_create_db(self, name):\n flag = \"pgsql_created_{}\".format(name)\n if self.pgsql_configured():\n if self.kv.get(flag):\n return True\n else:\n create_result = self.pgsql_query(\n \"CREATE DATABASE {0} OWNER postgres\".format(name)\n )\n grant_result = self.pgsql_query(\n \"GRANT ALL PRIVILEGES ON DATABASE {0} TO {1}\".format(\n name, self.kv.get(\"pgsql_user\")\n )\n )\n hookenv.log(\n \"DB Create: {}, Grant: {}\".format(create_result, grant_result),\n hookenv.DEBUG,\n )\n if create_result is None and grant_result is None:\n self.kv.set(\"pgsql_created_{}\".format(name), True)\n return create_result\n return False","def create_db(self, dbname, **params):\n return self.get_db(dbname, create=True, **params)","def init_db():\n current_app.logger.info('Creating database...')\n db.drop_all()\n db.create_all()\n db.session.commit()","def connect_dataBase(db_dir, create_cmd):\n just_created = False #flag of is the db is already exist\n \n if not os.path.isfile(db_dir):\n #create the db file in the directory\n with open(db_dir , 'w') as f:\n just_created = True\n #print 'database handler created -- ' , db_dir \n\n try:\n conn = lite.connect(db_dir)\n except lite.Error, e:\n #print \"Error %s:\" % db_dir\n sys.exit(1)\n finally:\n if just_created:\n #create the table \n create_dataBase(conn, create_cmd)\n return True","def settings_db_create(db_name=SETTINGS_DB_NAME, force=False):\n if not force and os.path.isfile(db_name):\n user_choice = input('Do you really want to drop database ? Type \"yes\" to continue\\n ')\n if not user_choice.isalpha() or not user_choice.lower() == 'yes':\n return False\n\n # DB creation logic goes here\n with lite.connect(db_name) as con:\n cur = con.cursor()\n cur.execute('DROP TABLE IF EXISTS PATHS')\n cur.execute(\"CREATE TABLE PATHS \"\n \"( LOGISIM_HOME VARCHAR NOT NULL,\\\n GRADING_PATH VARCHAR NOT NULL,\\\n IMPORT_PATH VARCHAR,\\\n GRADES_DB VARCHAR); \")\n cur.execute(\"CREATE TABLE LOCAL (\\\n GRADER_NAME VARCHAR,\\\n YEAR INT,\\\n SEMESTER CHAR (1),\\\n USE_STYLE BOOLEAN,\\\n SYNC_COMMAND VARCHAR);\")\n con.commit()\n return True","def createDB(dbName:str)->None:\n conn, cur = DBConnect()\n cur.execute(f\"CREATE DATABASE IF NOT EXISTS {dbName} CHARSET = utf8mb4 DEFAULT COLLATE = utf8mb4_unicode_ci;\")\n conn.commit()\n cur.close()","def add_db(self):\n name_db = self.name_db.get()\n if len(name_db) > 0:\n self.sql_database.db_name = name_db\n if self.sql_database.create_database():\n msg.showinfo(\n message=\"\".join(\n [str(self.name_db.get()), \" created as text_reader_\", str(self.sql_database.db_name)]))\n self.name_db.delete(0, tk.END)\n self.show_db_combobox()\n else:\n msg.showinfo(message=\"Failed\")\n else:\n msg.showinfo(message=\"Write db name!\")","def set_up_db():\n DATABASE.drop_tables([Customer])\n DATABASE.close()\n DATABASE.create_tables([Customer])\n DATABASE.close()","def CreateDB(self) :\r\n\t\ttry :\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateClassTable'])\r\n\t\t\tfor ii,classname in enumerate(self.SQLCMDs['ClassesList']) :\r\n\t\t\t\tself.DB_Cursor.execute(self.SQLCMDs['InsertClass'],(ii,classname))\r\n\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateSetTable'])\r\n\t\t\tfor ii,setname in enumerate(self.SQLCMDs['SetList']) :\r\n\t\t\t\tself.DB_Cursor.execute(self.SQLCMDs['InsertSet'],(ii,setname))\r\n\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateSampleTable'])\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateDictListTable'])\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateDictBuildTable'])\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateWordLists'])\r\n\t\t\tself.DB_Cursor.execute(self.SQLCMDs['CreateFeatureTable'])\r\n\t\t\tself.DB_Connect.commit()\r\n\t\texcept Exception as detail:\r\n\t\t\tlogging.error(\"Failed to create the database: %s\"%detail)\r\n\t\t\tself.DB_Connect.rollback()\r\n\t\treturn","def setupDatabases(con, options, dbList):\n currentDatabases = dbGetFirstColumnAsMap(con, \"select datname from pg_database where datistemplate = false\")\n currentRolenames = dbGetFirstColumnAsMap(con, \"select rolname from pg_roles\")\n trace(\"currentDatabases = \" + str(currentDatabases))\n for dbName in dbList:\n trace(\"dbName='%s'\" % str(dbName))\n setupDatabase(con, options, currentDatabases, currentRolenames, dbName, dbList[dbName])","def create_db():\r\n\r\n try:\r\n conn = sqlite3.connect('account.db')\r\n c = conn.cursor()\r\n c.execute('''CREATE TABLE accounts\r\n (\r\n username text,\r\n password text,\r\n access_level int\r\n )''')\r\n conn.commit()\r\n print(\"Successfully created database and table\")\r\n return True\r\n except BaseException:\r\n return False\r\n finally:\r\n if c is not None:\r\n c.close()\r\n if conn is not None:\r\n conn.close()","def recreate_db():\n drop_db()\n create_db()","def register_db():\n models = (Storage,\n AccessInfo\n )\n engine = create_engine(CONF.database.connection, echo=False)\n for model in models:\n model.metadata.create_all(engine)","def create_db(self, cnx):\n self.cursor = cnx.cursor()\n try:\n # Opening the file containing the SQL script\n sql_file = open(PATH_FILE, 'r')\n # Read file\n sql_text = sql_file.read()\n sql_stmts = sql_text.split(';')\n for s in sql_stmts:\n self.cursor.execute(s)\n # Graphical interface with Tkinter\n self.text_db_is_create = \"The database is created.\"\n # Mode console\n print(\"The database is created\")\n # Make sure db is committed\n self.cnx.commit()\n\n except connector.Error as err:\n # Graphical interface with Tkinter\n self.text_db_is_create = \"Failed creating database.\"\n # Mode console\n print(\"Failed creating database: {}\".format(err))\n exit(1)\n\n else:\n self.cursor.close()\n return cnx","def checkingConnection(self):\r\n if QSqlDatabase.contains():\r\n self.db = QSqlDatabase.database()\r\n self.db.setDatabaseName('database.sqlite')\r\n self.db.open()\r\n else:\r\n self.db = QSqlDatabase.addDatabase(\"QSQLITE\")\r\n self.db.setDatabaseName('database.sqlite')\r\n self.db.open()","def create_db(): \r\n env.db_user = prompt('DB user for %s:' % env.host, default=env.project_name)\r\n env.db_password = prompt('DB password for user %s:' % env.db_user)\r\n \r\n # -e echo-sql S no-superuser D no-createdb R no-createrole l can-login\r\n # P prompt-for-passwd -U <login role> -O <owner role> -h <hostname>\r\n # TODO find a way to use provided password! (use SQL instead of command)\r\n run('createuser -e -SDRlP -U %s -h %s %s' % (env.db_superuser, env.db_host, env.db_user)) \r\n # -U <login role> -O <owner role> -h <hostname>\r\n run('createdb -e -E UTF8 -O %s -U %s -h %s %s' % (env.db_user, env.db_superuser, env.db_host, env.project_name))","def create(self):\n db.create_all()","def test_database_creation(self):\r\n not_existing_wsp = \"doesnotexist.wsp\"\r\n path = os.path.join(settings.SALMON_WHISPER_DB_PATH, not_existing_wsp)\r\n self.assertEqual(os.path.exists(path), False)\r\n graph.WhisperDatabase(path)\r\n self.assertEqual(os.path.exists(path), True)","def create_base(self):\r\n self.mycursor.execute(\r\n 'CREATE DATABASE IF NOT EXISTS purbeurre CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci')\r\n self.mycursor.execute('USE purbeurre')"],"string":"[\n \"def create_db():\\n db.create_all()\\n click.echo(\\\"DB criado com sucesso!\\\")\",\n \"def create_db():\\n db.create_all()\\n print(\\\"DB Created\\\")\",\n \"def create_db():\\n db.create_all()\\n click.echo(\\\"Banco de dados criado\\\")\",\n \"def create_new_db():\\n global data_base, table\\n data_base = asksaveasfilename(title=\\\"Select file\\\", filetypes=((\\\"DATA BASE\\\", \\\"*.db\\\"), (\\\"all files\\\", \\\"*.*\\\")),\\n defaultextension='.db')\\n\\n if Path(data_base).suffix == '.db':\\n create_win_create_table()\\n else:\\n mistake_db_file()\",\n \"def create_db(self):\",\n \"def create_db():\\n db.create_all()\\n print('Database structure created successfully')\",\n \"def create():\\n\\tcreate_db()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create_db():\\n db.create_all()\",\n \"def create(name):\\n\\t\\treturn \\\"CREATE DATABASE {0};\\\".format(name)\",\n \"def create_database_stock_master():\\n sql = \\\"\\\"\\\"\\n CREATE DATABASE stock_master;\\n \\\"\\\"\\\"\\n excute_sql(sql,None)\",\n \"def _create_db(db_name):\\n template_conn.execute('commit')\\n template_conn.execute('create database {}'.format(db_name))\",\n \"def create_database():\\n try:\\n db.create_all()\\n print('Created tables successfully!')\\n except Exception:\\n print('Failed to create db. Make sure your database server is running')\",\n \"def create_db():\\n db.create_all()\\n print ('Intialized....!')\",\n \"def create_db(self, db_name):\\n if self.conf['database'] not in self.show_database():\\n sql = 'CREATE DATABASE IF NOT EXISTS %s CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci' % db_name\\n Log.debug('DB -> %s' % sql)\\n self.execute(sql)\",\n \"def create_db():\\n from sqlalchemy_utils import database_exists, create_database, drop_database\\n if not database_exists(DB_URL):\\n print('Creating database.')\\n create_database(DB_URL)\\n else:\\n drop_database(DB_URL)\\n create_database(DB_URL)\\n print(\\\"Deleted and created new database\\\")\\n create_tables()\",\n \"def createDb():\\n db.drop_all()\\n db.create_all()\",\n \"def make_db():\\n\\n db.create_all()\",\n \"def _create_db(self):\\n self.db = easydms.dbcore.Database(\\\":memory:\\\")\\n self.db.create_db()\",\n \"def create_db(self):\\n creation_query = f\\\"CREATE DATABASE {DB_NAME} CHARACTER SET 'utf8mb4' \\\"\\n existence_query = f\\\"USE {DB_NAME}\\\"\\n try:\\n self.cursor.execute(creation_query)\\n self.cursor.execute(existence_query)\\n print(f\\\"\\\\n La base de données |{DB_NAME}| a été créée \\\\n\\\")\\n except:\\n print(\\\"\\\\n Une erreur s'est produite lors \\\"\\n \\\"de la création de la base de données \\\\n\\\")\",\n \"def create_database():\\n create_db(app)\",\n \"def createdb(dbname):\\n os.system(\\\"createdb -w %s\\\" % dbname)\",\n \"def newDb(options, dbName, adminPswd, userPswd, viewerPswd):\\n if not re.match(\\\"^[A-Za-z][A-Za-z0-9_]*$\\\", dbName):\\n errorPrint(\\\"'%s' is not a valid database name\\\" % dbName)\\n return\\n\\n adminName = dbName + \\\"_admin\\\"\\n userName = dbName + \\\"_user\\\"\\n viewerName = dbName + \\\"_viewer\\\"\\n\\n setupDictionaryDatabases(options, {\\n 'databases': {\\n dbName: {\\n 'ownerRole': adminName,\\n 'roles': {\\n adminName: {\\n 'password': adminPswd,\\n 'role': 'admin'\\n },\\n userName: {\\n 'password': userPswd,\\n 'role': 'writer'\\n },\\n viewerName: {\\n 'password': viewerPswd,\\n 'role': 'reader'\\n }\\n }\\n }\\n }\\n })\",\n \"def createDB(dbname='ddsassignment3'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n print \\\"Count \\\",count\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print 'A database named {0} already exists'.format(dbname)\\n\\n # Clean up\\n cur.close()\\n con.commit()\\n con.close()\",\n \"def create_db():\\n _init_db()\\n db.create_all()\",\n \"def createDB(dbname='ddsassignment3'):\\r\\n # Connect to the default database\\r\\n con = getOpenConnection(dbname='postgres')\\r\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\r\\n cur = con.cursor()\\r\\n\\r\\n # Check if an existing database with the same name exists\\r\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\r\\n count = cur.fetchone()[0]\\r\\n if count == 0:\\r\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\r\\n else:\\r\\n print 'A database named {0} already exists'.format(dbname)\\r\\n\\r\\n # Clean up\\r\\n cur.close()\\r\\n con.commit()\\r\\n con.close()\",\n \"def setupDatabases(self):\\n param = self.getDefaultDatabaseConnectionParameter()\\n db = DatabaseFactory.getDatabase(self.defaultDriver(), {})\\n db.createDatabase(param)\\n db.connect(param)\\n if db.isConnected():\\n self.settingsDb = db\\n db.createObservations()\\n db.createSensors()\\n else:\\n return False\\n # replace by settings validation method later\\n return self.check()\",\n \"def create_db():\\n db_url = engine.url\\n if not database_exists(db_url):\\n create_database(db_url)\\n base.metadata.create_all()\",\n \"def makeDatabase(con, options, dbName, dbOwnerRole, dbInfo, dbRoles):\\n ownerRole = dbInfo[\\\"ownerRole\\\"]\\n userRole = \\\"{0}_common_user_role\\\".format(dbName)\\n viewerRole = \\\"{0}_common_viewer_role\\\".format(dbName)\\n \\n optionalDbExecute(con, options, \\\"CREATE ROLE {0}\\\".format(userRole))\\n optionalDbExecute(con, options, \\\"CREATE ROLE {0}\\\".format(viewerRole))\\n\\n trace(\\\"Creating database %s with owner '%s'\\\" % (dbName, ownerRole))\\n optionalDbExecute(con, options, \\\"CREATE DATABASE %s WITH OWNER %s\\\" % (dbName, ownerRole))\\n con2 = None\\n try:\\n con2 = dbConnect(database = dbName, user = options[\\\"dbuser\\\"], password = options[\\\"dbpassword\\\"], host = options[\\\"dbhost\\\"])\\n\\n optionalDbExecute(con2, options, \\\"REVOKE ALL on DATABASE {0} FROM {1}\\\".format(dbName, viewerRole))\\n optionalDbExecute(con2, options, \\\"REVOKE ALL on DATABASE {0} FROM {1}\\\".format(dbName, userRole))\\n for name in dbRoles:\\n userInfo = dbRoles[name]\\n if userInfo[\\\"role\\\"] == \\\"writer\\\" or userInfo[\\\"role\\\"] == \\\"reader\\\":\\n optionalDbExecute(con2, options, \\\"REVOKE ALL on DATABASE {0} FROM {1}\\\".format(dbName, name))\\n\\n # user can do everything viewer can\\n optionalDbExecute(con2, options, \\\"GRANT {0} TO {1}\\\".format(viewerRole, userRole))\\n # admin can do everything user and viewer can\\n optionalDbExecute(con2, options, \\\"GRANT {0} TO {1}\\\".format(userRole, ownerRole))\\n\\n # viewer, user, admin can connect\\n optionalDbExecute(con2, options, \\\"GRANT CONNECT ON DATABASE {0} TO {1}\\\".format(dbName, viewerRole))\\n\\n # create a schema we can optionally use *\\n schemaName = \\\"{0}_db_common\\\".format(dbName)\\n optionalDbExecute(con2, options, \\\"CREATE SCHEMA if not exists {0} AUTHORIZATION {1}\\\".format(schemaName, ownerRole))\\n\\n # search_path is not inherited, so set it here\\n for role in [ ownerRole, userRole, viewerRole ]:\\n optionalDbExecute(con2, options, \\\"ALTER ROLE {1} IN DATABASE {0} SET search_path = public, {2}\\\".format(dbName, role, schemaName))\\n\\n # viewer,user can select from schema\\n optionalDbExecute(con2, options, \\\"GRANT USAGE ON SCHEMA {0} TO {1}\\\".format(schemaName, viewerRole))\\n # admin can create on schema\\n optionalDbExecute(con2, options, \\\"GRANT CREATE ON SCHEMA {0} TO {1}\\\".format(schemaName, ownerRole))\\n\\n # viewer, user, admin can select on tables\\n optionalDbExecute(con2, options, \\\"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT SELECT ON TABLES TO {0}\\\".format(viewerRole, ownerRole))\\n # user, admin can ins/upd/del/tru on tables\\n optionalDbExecute(con2, options, \\\"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT INSERT, UPDATE, DELETE, TRUNCATE ON TABLES TO {0}\\\".format(userRole, ownerRole))\\n # user, admin can update on sequences\\n optionalDbExecute(con2, options, \\\"ALTER DEFAULT PRIVILEGES FOR ROLE {1} GRANT USAGE, SELECT, UPDATE ON SEQUENCES TO {0}\\\".format(userRole, ownerRole))\\n\\n # user, admin can create temp tables\\n optionalDbExecute(con2, options, \\\"GRANT TEMP ON DATABASE {0} TO {1}\\\".format(dbName, userRole))\\n\\n for name in dbRoles:\\n userInfo = dbRoles[name]\\n if userInfo[\\\"role\\\"] == \\\"writer\\\":\\n optionalDbExecute(con2, options, \\\"GRANT {0} TO {1}\\\".format(userRole, name))\\n elif userInfo[\\\"role\\\"] == \\\"reader\\\":\\n optionalDbExecute(con2, options, \\\"GRANT {0} TO {1}\\\".format(viewerRole, name))\\n\\n # search_path is not inherited, so set it here\\n optionalDbExecute(con2, options, \\\"ALTER ROLE {1} IN DATABASE {0} SET search_path = public, {2}\\\".format(dbName, name, schemaName))\\n\\n except psycopg2.DatabaseError as e:\\n die('Error %s' % e)\\n\\n finally:\\n if con2:\\n con2.commit()\\n con2.close()\",\n \"def test_create_database(self):\\n self.assertTrue(self.ss.create_database(self.test_database),\\n \\\"Create testing database\\\")\\n self.assertTrue(os.path.exists(self.test_database))\\n self.assertNotEqual(self.test_database, self.ss.data_file(),\\n \\\"Should not connect to created database\\\")\",\n \"def createdb():\\n db.create_all()\",\n \"def create_database():\\n with connection:\\n connection.execute(CREATE_MOVIE_TABLE)\\n connection.execute(CREATE_USER_TABLE)\\n connection.execute(CREATE_WATCHED_TABLE)\",\n \"def database(name, **kwargs):\\n if not database_exists(name, **kwargs):\\n create_database(name, **kwargs)\",\n \"def initdb():\\n db.create_all()\",\n \"def initdb():\\n db.create_all()\",\n \"def createDB(dbname='ddsassignment3'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print 'A database named {0} already exists'.format(dbname)\\n\\n # Clean up\\n cur.close()\\n con.commit()\\n con.close()\",\n \"def __KCreateDB(self):\\n if self.create_db_method == \\\"Create New\\\":\\n if self.page_size == \\\"Default\\\":\\n createCommand = \\\"CREATE DATABASE '%s' USER '%s' PASSWORD '%s'\\\" % (self.__dsn,\\n self.user_name,\\n self.user_password)\\n else:\\n createCommand = \\\"CREATE DATABASE '%s' USER '%s' PASSWORD '%s' PAGE_SIZE=%d\\\" % (self.__dsn,\\n self.user_name,\\n self.user_password,\\n int(self.page_size))\\n try:\\n conn= kdb.create_database(createCommand, int(self.sql_dialect))\\n\\n conn.close()\\n\\n except:\\n self.__result.NoteException(cause=\\\"Exception raised while creating database.\\\")\\n return\",\n \"def createDB(dbname='dds_assignment1'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print('A database named {0} already exists'.format(dbname))\\n\\n # Clean up\\n cur.close()\\n con.close()\",\n \"def createdb():\\n if database.exists():\\n raise click.UsageError(\\n click.style('Database already exists at {}.'\\n .format(database.url), fg='red')\\n )\\n else:\\n database.create()\\n click.echo(OK)\",\n \"def createDB(dbname='dds_assignment'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print 'A database named {0} already exists'.format(dbname)\\n\\n # Clean up\\n cur.close()\\n con.commit()\\n con.close()\",\n \"def create_databases():\\n db_connection = connect_to_db()\\n\\n # Create database tables.\\n create_tables(db_connection)\\n\\n # Populate water tables.\\n populate_water_tables(db_connection)\\n\\n # station_data = get_station_data()\\n # station = station_data.query('ŠIFRA == 30301')\\n # print(station)\\n # index = station.index[0]\\n # lat = station.at[index, 'LAT']\\n # lng = station.at[index, 'LON']\\n # name = f\\\"{station.at[index, 'VODOMERNA POSTAJA']} ({station.at[index, 'VODOTOK']})\\\"\\n # print(index, lat, lng, name)\\n\\n # Populate location tables\\n # populate_locations(db_connection)\\n\\n # Populate weather tables\\n populate_weather(db_connection)\\n\\n db_connection.commit()\\n db_connection.close()\",\n \"def createDB(dbname='dds_assignment'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print('A database named ' + dbname + ' already exists')\\n\\n # Clean up\\n cur.close()\\n con.close()\",\n \"def createDB(dbname='dds_assignment'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print 'A database named {0} already exists'.format(dbname)\\n\\n # Clean up\\n cur.close()\\n con.close()\",\n \"def createDB(dbname='dds_assignment'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print 'A database named {0} already exists'.format(dbname)\\n\\n # Clean up\\n cur.close()\\n con.close()\",\n \"def create_empty_db():\\r\\n drop_db()\\r\\n database.create_tables([Customer])\\r\\n database.close()\",\n \"def createDB(dbname='dds_assignment2'):\\n # Connect to the default database\\n con = getOpenConnection(dbname='postgres')\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\n cur = con.cursor()\\n\\n # Check if an existing database with the same name exists\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\n count = cur.fetchone()[0]\\n if count == 0:\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\n else:\\n print('A database named {0} already exists'.format(dbname))\\n\\n # Clean up\\n cur.close()\\n con.commit()\\n con.close()\",\n \"def create_database():\\n Base.metadata.create_all(bind=engine)\",\n \"def new_database(app):\\n app.status.message(\\\"Opening a folder..\\\")\\n path = app.dialog.directory(\\\"Select a folder for the new database..\\\")\\n if path == '':\\n app.status.message('') \\n return\\n app.status.cursorToHourglass()\\n app.close()\\n folder = db.database(path=path, \\n status = app.status, \\n dialog = app.dialog)\\n app.display(folder)\\n app.status.hide()\\n app.status.cursorToNormal()\",\n \"def create():\\n\\n from slicr.extensions import db\\n\\n click.echo('creating database...')\\n\\n db.create_all()\",\n \"def create_database():\\n # Depending on your local settings, you may need to specify a user and password, e.g.\\n # conn = psycopg2.connect(dbname=\\\"postgres\\\", user=\\\"postgres\\\", password=\\\"password\\\")\\n conn = psycopg2.connect(dbname=\\\"postgres\\\")\\n conn.autocommit = True # it seems this mode is needed to make a db\\n conn.set_isolation_level(0) # also this for dropping db\\n\\n # un-comment this line if you already have a database called\\n # `opportunity_youth` and you want to drop it\\n # execute_sql_script(conn, \\\"01_drop_old_database.sql\\\")\\n execute_sql_script(conn, \\\"02_create_new_database.sql\\\")\\n\\n conn.close()\",\n \"def fd_create(db_name):\\n # check db exists\\n if db_name in (\\n FdMultiController.fd_list() + [FdMultiController._db_registry_name]\\n ):\\n raise Exception(\\\"DB \\\" + db_name + \\\" already exists\\\")\\n try:\\n os.remove(FdMultiController._path_generator(db_name))\\n except Exception:\\n pass\\n # create database and read schema\\n db_address = FdMultiController._path_generator(db_name)\\n conn = None\\n try:\\n with open(FdMultiController._path_generator(\\\"dbSchema.sql\\\")[:-3]) as file:\\n conn = sqlite3.connect(db_address)\\n curr = conn.cursor()\\n curr.executescript(file.read())\\n conn.close()\\n FdMultiController._add_name(db_name)\\n return True\\n except Exception:\\n # generic class used to account for OS and import exceptions\\n return False\",\n \"def init_db():\\n\\tdb.drop_all()\\n\\tdb.create_all()\\n\\n\\tprint(\\\"Initialized Database.\\\")\\n\\treturn\",\n \"def create_db(drop_first=False):\\n\\n # if drop_first is True, delete database tables first\\n if drop_first:\\n db.drop_all()\\n db.create_all()\\n print(f'[INFO] Created database tables.')\",\n \"def create_databases(self, overwrite = False):\\r\\n self.validate_config()\\r\\n self.template_runner.create_databases(overwrite)\",\n \"def init_db():\\n db.drop_all()\\n db.create_all()\\n\\n print(\\\"Initialized Connect 4 Database.\\\")\",\n \"def setup_database(self):\\n self.db.setup_database()\",\n \"def create_db(num_users=5):\\n db.create_all()\",\n \"def create_prod_db():\\n _create_database(is_production=True)\",\n \"def create_db():\\n # check for DB existance\\n db_file = vmcheckerpaths.db_file()\\n if not os.path.isfile(db_file):\\n create_db_tables(db_file)\\n else:\\n _logger.info('Skipping existing Sqlite3 DB file %s' % db_file)\",\n \"def create_db(db_name: str = DB_NAME) -> DBConnection:\\n connection = open_db(db_name)\\n connection.execute(\\\"\\\"\\\"\\n CREATE TABLE docs\\n (did INTEGER PRIMARY KEY, \\n title TEXT NOT NULL, \\n url TEXT NOT NULL)\\n \\\"\\\"\\\")\\n connection.execute(\\\"\\\"\\\"\\n CREATE TABLE tfs \\n (did INTEGER,\\n term TEXT NOT NULL,\\n tf INTEGER)\\n \\\"\\\"\\\")\\n connection.execute(\\\"\\\"\\\"\\n CREATE TABLE boost\\n (did INTEGER,\\n date INTEGER,\\n page INTEGER\\n )\\\"\\\"\\\")\\n print(f\\\"[+] Created db {DB_NAME}\\\")\\n return connection\",\n \"def __create_db(self):\\n\\n if not database_exists(self.db.url):\\n create_database(self.db.url)\\n print(\\\"DB Created\\\")\\n\\n return \\\"Does DB exist? {}\\\".format(database_exists(self.db.url))\",\n \"def db_createall():\\n db.create_all()\",\n \"def create_DB (name):\\n engine = create_engine('sqlite:///%s' % name)\\n Base.metadata.create_all(engine)\",\n \"def test_creation_when_no_database_exists(self):\\n database_filename = \\\"test.db\\\"\\n\\n # Delete the test database if it exists.\\n test_database = os.path.join(os.getcwd(), database_filename)\\n if os.path.exists(test_database):\\n os.remove(test_database)\\n\\n # Create the database object, build the database\\n database = app.database.Database(database_filename)\\n database.create_database()\\n\\n # Pull out the table names from the database we've created.\\n column_names = extract_column_names(database_filename)\\n\\n # Assert that they are as expected:\\n for column_name in app.database.database_columns:\\n self.assertEqual(\\n True,\\n column_name in column_names,\\n \\\"Database creation process did not yield the column names expected. Missing: {0}\\\".format(column_name)\\n )\",\n \"def create_db_execute(self):\\n self.execute(query=self.db_create_schema.format(self.db_name))\",\n \"def create_db(self, dbname):\\n if dbname not in self.list_dbs():\\n return self.put(dbname).text\\n else:\\n raise ExistingDatabase(dbname)\",\n \"def createdb():\\n print \\\"here\\\"\\n db.create_all()\",\n \"def create_db(dbname):\\r\\n # Connect to the default database\\r\\n con = getopenconnection(dbname='postgres')\\r\\n con.set_isolation_level(psycopg2.extensions.ISOLATION_LEVEL_AUTOCOMMIT)\\r\\n cur = con.cursor()\\r\\n\\r\\n # Check if an existing database with the same name exists\\r\\n cur.execute('SELECT COUNT(*) FROM pg_catalog.pg_database WHERE datname=\\\\'%s\\\\'' % (dbname,))\\r\\n count = cur.fetchone()[0]\\r\\n if count == 0:\\r\\n cur.execute('CREATE DATABASE %s' % (dbname,)) # Create the database\\r\\n else:\\r\\n print 'A database named {0} already exists'.format(dbname)\\r\\n\\r\\n # Clean up\\r\\n cur.close()\\r\\n con.close()\",\n \"def createDataBase(mysql,dbase):\\n\\tsql = 'CREATE DATABASE IF NOT EXISTS '+ dbase + ';'\\n\\tmysql.query(sql)\\n\\tmysql.select_db(dbase)\\n\\tsql = 'DROP TABLE IF EXISTS names;'\\n\\tmysql.query(sql)\\n\\tsql = 'DROP TABLE IF EXISTS files;'\\n\\tmysql.query(sql)\\n\\tsql = 'DROP TABLE IF EXISTS linesinfile;'\\n\\tmysql.query(sql)\\n\\tsql = 'DROP TABLE IF EXISTS allfiles;'\\n\\tmysql.query(sql)\\n\\tsql = 'DROP TABLE IF EXISTS allnames;'\\n\\tmysql.query(sql)\\n\\tsql = 'CREATE TABLE names (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\\\\n\\tname TINYTEXT NOT NULL);'\\n\\tmysql.query(sql)\\n\\tsql = 'CREATE TABLE files (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\\\\n\\t\\tname BIGINT NOT NULL, \\\\\\n\\t\\tfilename TEXT NOT NULL \\\\\\n\\t\\tREFERENCES names(id));'\\n\\tmysql.query(sql)\\n\\tsql = 'CREATE TABLE linesinfile (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\\\\n\\t\\tfilename BIGINT NOT NULL, \\\\\\n\\t\\tnumber TEXT NOT NULL, \\\\\\n\\t\\tref TINYTEXT NOT NULL \\\\\\n\\t\\tREFERENCES files(id));'\\n\\tmysql.query(sql) \\n\\tsql = 'CREATE TABLE allfiles (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\\\\n\\tfile TEXT NOT NULL);'\\n\\tmysql.query(sql)\\n\\tsql = 'CREATE TABLE allnames (id BIGINT NOT NULL AUTO_INCREMENT PRIMARY KEY, \\\\\\n\\t\\tfile BIGINT NOT NULL, \\\\\\n\\t\\tname TEXT NOT NULL \\\\\\n\\t\\tREFERENCES allfiles(id));'\\n\\tmysql.query(sql)\",\n \"def create_database_future_master():\\n sql = \\\"\\\"\\\"\\n CREATE DATABASE future_master;\\n \\\"\\\"\\\"\\n excute_sql(sql, None)\",\n \"def setdb():\\n\\n if not database_exists(DB_URL):\\n print('Creating database.')\\n create_database(DB_URL)\\n\\n print('Creating tables.')\\n db.create_all()\\n print('Shiny!')\",\n \"def db_create():\\n db.drop_all()\\n db.create_all()\\n db.session.commit()\",\n \"def pgsql_create_db(self, name):\\n flag = \\\"pgsql_created_{}\\\".format(name)\\n if self.pgsql_configured():\\n if self.kv.get(flag):\\n return True\\n else:\\n create_result = self.pgsql_query(\\n \\\"CREATE DATABASE {0} OWNER postgres\\\".format(name)\\n )\\n grant_result = self.pgsql_query(\\n \\\"GRANT ALL PRIVILEGES ON DATABASE {0} TO {1}\\\".format(\\n name, self.kv.get(\\\"pgsql_user\\\")\\n )\\n )\\n hookenv.log(\\n \\\"DB Create: {}, Grant: {}\\\".format(create_result, grant_result),\\n hookenv.DEBUG,\\n )\\n if create_result is None and grant_result is None:\\n self.kv.set(\\\"pgsql_created_{}\\\".format(name), True)\\n return create_result\\n return False\",\n \"def create_db(self, dbname, **params):\\n return self.get_db(dbname, create=True, **params)\",\n \"def init_db():\\n current_app.logger.info('Creating database...')\\n db.drop_all()\\n db.create_all()\\n db.session.commit()\",\n \"def connect_dataBase(db_dir, create_cmd):\\n just_created = False #flag of is the db is already exist\\n \\n if not os.path.isfile(db_dir):\\n #create the db file in the directory\\n with open(db_dir , 'w') as f:\\n just_created = True\\n #print 'database handler created -- ' , db_dir \\n\\n try:\\n conn = lite.connect(db_dir)\\n except lite.Error, e:\\n #print \\\"Error %s:\\\" % db_dir\\n sys.exit(1)\\n finally:\\n if just_created:\\n #create the table \\n create_dataBase(conn, create_cmd)\\n return True\",\n \"def settings_db_create(db_name=SETTINGS_DB_NAME, force=False):\\n if not force and os.path.isfile(db_name):\\n user_choice = input('Do you really want to drop database ? Type \\\"yes\\\" to continue\\\\n ')\\n if not user_choice.isalpha() or not user_choice.lower() == 'yes':\\n return False\\n\\n # DB creation logic goes here\\n with lite.connect(db_name) as con:\\n cur = con.cursor()\\n cur.execute('DROP TABLE IF EXISTS PATHS')\\n cur.execute(\\\"CREATE TABLE PATHS \\\"\\n \\\"( LOGISIM_HOME VARCHAR NOT NULL,\\\\\\n GRADING_PATH VARCHAR NOT NULL,\\\\\\n IMPORT_PATH VARCHAR,\\\\\\n GRADES_DB VARCHAR); \\\")\\n cur.execute(\\\"CREATE TABLE LOCAL (\\\\\\n GRADER_NAME VARCHAR,\\\\\\n YEAR INT,\\\\\\n SEMESTER CHAR (1),\\\\\\n USE_STYLE BOOLEAN,\\\\\\n SYNC_COMMAND VARCHAR);\\\")\\n con.commit()\\n return True\",\n \"def createDB(dbName:str)->None:\\n conn, cur = DBConnect()\\n cur.execute(f\\\"CREATE DATABASE IF NOT EXISTS {dbName} CHARSET = utf8mb4 DEFAULT COLLATE = utf8mb4_unicode_ci;\\\")\\n conn.commit()\\n cur.close()\",\n \"def add_db(self):\\n name_db = self.name_db.get()\\n if len(name_db) > 0:\\n self.sql_database.db_name = name_db\\n if self.sql_database.create_database():\\n msg.showinfo(\\n message=\\\"\\\".join(\\n [str(self.name_db.get()), \\\" created as text_reader_\\\", str(self.sql_database.db_name)]))\\n self.name_db.delete(0, tk.END)\\n self.show_db_combobox()\\n else:\\n msg.showinfo(message=\\\"Failed\\\")\\n else:\\n msg.showinfo(message=\\\"Write db name!\\\")\",\n \"def set_up_db():\\n DATABASE.drop_tables([Customer])\\n DATABASE.close()\\n DATABASE.create_tables([Customer])\\n DATABASE.close()\",\n \"def CreateDB(self) :\\r\\n\\t\\ttry :\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateClassTable'])\\r\\n\\t\\t\\tfor ii,classname in enumerate(self.SQLCMDs['ClassesList']) :\\r\\n\\t\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['InsertClass'],(ii,classname))\\r\\n\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateSetTable'])\\r\\n\\t\\t\\tfor ii,setname in enumerate(self.SQLCMDs['SetList']) :\\r\\n\\t\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['InsertSet'],(ii,setname))\\r\\n\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateSampleTable'])\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateDictListTable'])\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateDictBuildTable'])\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateWordLists'])\\r\\n\\t\\t\\tself.DB_Cursor.execute(self.SQLCMDs['CreateFeatureTable'])\\r\\n\\t\\t\\tself.DB_Connect.commit()\\r\\n\\t\\texcept Exception as detail:\\r\\n\\t\\t\\tlogging.error(\\\"Failed to create the database: %s\\\"%detail)\\r\\n\\t\\t\\tself.DB_Connect.rollback()\\r\\n\\t\\treturn\",\n \"def setupDatabases(con, options, dbList):\\n currentDatabases = dbGetFirstColumnAsMap(con, \\\"select datname from pg_database where datistemplate = false\\\")\\n currentRolenames = dbGetFirstColumnAsMap(con, \\\"select rolname from pg_roles\\\")\\n trace(\\\"currentDatabases = \\\" + str(currentDatabases))\\n for dbName in dbList:\\n trace(\\\"dbName='%s'\\\" % str(dbName))\\n setupDatabase(con, options, currentDatabases, currentRolenames, dbName, dbList[dbName])\",\n \"def create_db():\\r\\n\\r\\n try:\\r\\n conn = sqlite3.connect('account.db')\\r\\n c = conn.cursor()\\r\\n c.execute('''CREATE TABLE accounts\\r\\n (\\r\\n username text,\\r\\n password text,\\r\\n access_level int\\r\\n )''')\\r\\n conn.commit()\\r\\n print(\\\"Successfully created database and table\\\")\\r\\n return True\\r\\n except BaseException:\\r\\n return False\\r\\n finally:\\r\\n if c is not None:\\r\\n c.close()\\r\\n if conn is not None:\\r\\n conn.close()\",\n \"def recreate_db():\\n drop_db()\\n create_db()\",\n \"def register_db():\\n models = (Storage,\\n AccessInfo\\n )\\n engine = create_engine(CONF.database.connection, echo=False)\\n for model in models:\\n model.metadata.create_all(engine)\",\n \"def create_db(self, cnx):\\n self.cursor = cnx.cursor()\\n try:\\n # Opening the file containing the SQL script\\n sql_file = open(PATH_FILE, 'r')\\n # Read file\\n sql_text = sql_file.read()\\n sql_stmts = sql_text.split(';')\\n for s in sql_stmts:\\n self.cursor.execute(s)\\n # Graphical interface with Tkinter\\n self.text_db_is_create = \\\"The database is created.\\\"\\n # Mode console\\n print(\\\"The database is created\\\")\\n # Make sure db is committed\\n self.cnx.commit()\\n\\n except connector.Error as err:\\n # Graphical interface with Tkinter\\n self.text_db_is_create = \\\"Failed creating database.\\\"\\n # Mode console\\n print(\\\"Failed creating database: {}\\\".format(err))\\n exit(1)\\n\\n else:\\n self.cursor.close()\\n return cnx\",\n \"def checkingConnection(self):\\r\\n if QSqlDatabase.contains():\\r\\n self.db = QSqlDatabase.database()\\r\\n self.db.setDatabaseName('database.sqlite')\\r\\n self.db.open()\\r\\n else:\\r\\n self.db = QSqlDatabase.addDatabase(\\\"QSQLITE\\\")\\r\\n self.db.setDatabaseName('database.sqlite')\\r\\n self.db.open()\",\n \"def create_db(): \\r\\n env.db_user = prompt('DB user for %s:' % env.host, default=env.project_name)\\r\\n env.db_password = prompt('DB password for user %s:' % env.db_user)\\r\\n \\r\\n # -e echo-sql S no-superuser D no-createdb R no-createrole l can-login\\r\\n # P prompt-for-passwd -U <login role> -O <owner role> -h <hostname>\\r\\n # TODO find a way to use provided password! (use SQL instead of command)\\r\\n run('createuser -e -SDRlP -U %s -h %s %s' % (env.db_superuser, env.db_host, env.db_user)) \\r\\n # -U <login role> -O <owner role> -h <hostname>\\r\\n run('createdb -e -E UTF8 -O %s -U %s -h %s %s' % (env.db_user, env.db_superuser, env.db_host, env.project_name))\",\n \"def create(self):\\n db.create_all()\",\n \"def test_database_creation(self):\\r\\n not_existing_wsp = \\\"doesnotexist.wsp\\\"\\r\\n path = os.path.join(settings.SALMON_WHISPER_DB_PATH, not_existing_wsp)\\r\\n self.assertEqual(os.path.exists(path), False)\\r\\n graph.WhisperDatabase(path)\\r\\n self.assertEqual(os.path.exists(path), True)\",\n \"def create_base(self):\\r\\n self.mycursor.execute(\\r\\n 'CREATE DATABASE IF NOT EXISTS purbeurre CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci')\\r\\n self.mycursor.execute('USE purbeurre')\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7011877","0.695819","0.69425726","0.69318235","0.6931772","0.6898847","0.68810636","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.68499804","0.6847495","0.6831007","0.68187195","0.6812667","0.68034154","0.6783089","0.6777869","0.67613846","0.67233837","0.6720512","0.6710088","0.66831577","0.6681635","0.66720057","0.6668828","0.66671085","0.6661016","0.66063577","0.6599723","0.6599255","0.6588901","0.65872383","0.65841603","0.65555483","0.65510476","0.65510476","0.6537501","0.6537286","0.6534979","0.6532004","0.65178895","0.6511472","0.6509117","0.6502334","0.6502334","0.65003777","0.64843416","0.6472324","0.64622974","0.6455018","0.6451562","0.6442986","0.6442289","0.6434454","0.64340675","0.6420094","0.64092606","0.6404011","0.63754886","0.6371545","0.63651747","0.63554084","0.63478136","0.63451916","0.6333748","0.631922","0.6316195","0.6300591","0.62981975","0.62925315","0.62835205","0.62822205","0.6278593","0.62700385","0.62572","0.62516034","0.62505555","0.6244027","0.62394696","0.6234986","0.6234407","0.6231044","0.62300026","0.6229202","0.6211874","0.6200241","0.619796","0.61914206","0.6186542","0.61854535","0.6182419","0.6179298"],"string":"[\n \"0.7011877\",\n \"0.695819\",\n \"0.69425726\",\n \"0.69318235\",\n \"0.6931772\",\n \"0.6898847\",\n \"0.68810636\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.68499804\",\n \"0.6847495\",\n \"0.6831007\",\n \"0.68187195\",\n \"0.6812667\",\n \"0.68034154\",\n \"0.6783089\",\n \"0.6777869\",\n \"0.67613846\",\n \"0.67233837\",\n \"0.6720512\",\n \"0.6710088\",\n \"0.66831577\",\n \"0.6681635\",\n \"0.66720057\",\n \"0.6668828\",\n \"0.66671085\",\n \"0.6661016\",\n \"0.66063577\",\n \"0.6599723\",\n \"0.6599255\",\n \"0.6588901\",\n \"0.65872383\",\n \"0.65841603\",\n \"0.65555483\",\n \"0.65510476\",\n \"0.65510476\",\n \"0.6537501\",\n \"0.6537286\",\n \"0.6534979\",\n \"0.6532004\",\n \"0.65178895\",\n \"0.6511472\",\n \"0.6509117\",\n \"0.6502334\",\n \"0.6502334\",\n \"0.65003777\",\n \"0.64843416\",\n \"0.6472324\",\n \"0.64622974\",\n \"0.6455018\",\n \"0.6451562\",\n \"0.6442986\",\n \"0.6442289\",\n \"0.6434454\",\n \"0.64340675\",\n \"0.6420094\",\n \"0.64092606\",\n \"0.6404011\",\n \"0.63754886\",\n \"0.6371545\",\n \"0.63651747\",\n \"0.63554084\",\n \"0.63478136\",\n \"0.63451916\",\n \"0.6333748\",\n \"0.631922\",\n \"0.6316195\",\n \"0.6300591\",\n \"0.62981975\",\n \"0.62925315\",\n \"0.62835205\",\n \"0.62822205\",\n \"0.6278593\",\n \"0.62700385\",\n \"0.62572\",\n \"0.62516034\",\n \"0.62505555\",\n \"0.6244027\",\n \"0.62394696\",\n \"0.6234986\",\n \"0.6234407\",\n \"0.6231044\",\n \"0.62300026\",\n \"0.6229202\",\n \"0.6211874\",\n \"0.6200241\",\n \"0.619796\",\n \"0.61914206\",\n \"0.6186542\",\n \"0.61854535\",\n \"0.6182419\",\n \"0.6179298\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6871423"},"document_rank":{"kind":"string","value":"7"}}},{"rowIdx":20198,"cells":{"query":{"kind":"string","value":"Returns a drop table or database SQL statement."},"document":{"kind":"string","value":"def drop_statement(self, object_type, object_name):\n drop_statement = \"DROP %s %s\" % (object_type, object_name)\n return drop_statement"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def drop(name):\n\t\treturn \"DROP DATABASE {0};\".format(name)","def _get_sql_drop_table(table_attr):\n template = 'DROP TABLE IF EXISTS \"%s\" CASCADE;' % (table_attr['name'])\n return template","def drop_statement(self, objecttype, objectname):\n statement = Engine.drop_statement(self, objecttype, objectname)\n statement += \" CASCADE;\"\n return statement.replace(\" DATABASE \", \" SCHEMA \")","def drop_table(self):\n\n return \"\"\"DROP TABLE \"users\\\"\"\"\"","def drop_table(self, schema, table):\n sql = f'set role {self.write_role}; ' \\\n + f'DROP TABLE IF EXISTS {schema}.{table};'\n return sql","def drop_table(conn, drop_table_sql):\n try:\n c = conn.cursor()\n c.execute(drop_table_sql)\n except Error as e:\n print(e)","def drop_table(database, table):\n sql = \"\"\"DROP TABLE %s\"\"\" % table\n print \"Dropping Table %s from the Database %s\" % (table, database)\n execute_and_commit_sql(database, sql)\n return None","def drop_table(self):\n sql = 'DROP TABLE {}'.format(self.TABLE_NAME)\n yield self._pool.execute(sql)","def drop_table(self, table_name):\n drop_command = \"DROP TABLE {}\".format(table_name)\n try:\n self.cursor.execute(drop_command)\n status = 'Table {} dropped'.format(table_name)\n except p.Error as exception:\n status = 'Exception occured in drop_table()'\n print(exception.pgerror)","def dropTable(self,table):\n query = \"DROP TABLE \"+table\n\tcur = self.db.cursor()\n\ttry:\n\t iQuery = self.updateLog(query)\n\t cur.execute(iQuery)\n# self.cursor.execute(iQuery)\n\texcept:\n\t self.log.write(\"No %s table found\\n\"%table)\n\tcur.close()","def get_drop(s):\n s = match_token(s, 'DROP')\n s = match_token(s, 'ROLLUP')\n s = match_token(s, 'VIEW')\n s, rollup_view_name = get_token(s)\n t = drop_rollup_str(rollup_view_name)\n return (s, t)","def drop_created_table(opts, stats):\n print(\"--------------------------------------\")\n print(\"Dropping created table %s\" % (opts.table_name, ))\n print(\"--------------------------------------\")\n print(timestamp())\n sql = \"DROP TABLE %s\" % (opts.table_name, )\n cmd = 'echo \"%s\" | impala-shell -i %s -f -' % (sql, opts.impalad_address)\n run_command(opts, cmd)","def as_sql(self):\r\n assert len(self.query.tables) == 1, \\\r\n \"Can only delete from one table at a time.\"\r\n qn = self.quote_name_unless_alias\r\n #=======================================================================\r\n # self._hasConstraints(self.query.tables[0])\r\n #=======================================================================\r\n \r\n result = ['DELETE FROM %s' % qn(self.query.tables[0])]\r\n where, params = self.query.where.as_sql(qn=qn, connection=self.connection)\r\n if where:\r\n result.append('WHERE %s' % where)\r\n ##DOTO: Delete after test\r\n #=======================================================================\r\n # print '>>>',result,params\r\n # if result[0] == 'DELETE FROM \"django_flatpage_sites\"' :\r\n # import pdb; pdb.set_trace()\r\n #=======================================================================\r\n return ' '.join(result), tuple(params)","def drop_tables(session):\n\n for query in drop_table_queries:\n session.execute(query)","def drop(self, alter_table=True):\n if self.name == 'PRIMARY':\n return \"DROP PRIMARY KEY\"\n elif alter_table:\n return \"DROP INDEX `%s`\" % (self.name)\n else:\n return \"DROP INDEX `%s` ON `%s`\" % (self.name, self.parent.name)","async def _delete_stmt(self):\n return \"DELETE FROM {} WHERE {}=$1\".format(self.table,\n self.identifier_key)","def drop_table(cls):\n if not connection.connected:\n raise Exception('Not connected to the database.')\n sql = u'DROP TABLE IF EXISTS %s' % cls.table()\n connection.execute(sql)","def table_drop(self, table):\n\n stmt = 'DROP TABLE %s' % table\n\n curs = self.cursor()\n try:\n curs.execute(stmt)\n except sqlite3.OperationalError:\n pass\n finally:\n curs.close()","def test_drop(self):\n my_conn = MySQL(*self.conn_params)\n sql = \"CREATE TABLE table1 (id integer, column1 varchar(100), \" \\\n \"column2 double)\"\n my_conn.execute(sql)\n my_conn.get_table('table1')\n my_conn.drop('table1') # DROP example\n with self.assertRaises(InvalidRequestError):\n my_conn.get_table('table1')","def drop_tables(session):\n for query in drop_table_queries:\n session.execute(query)","def drop(self):\n self.__init__()\n cursor = self.connection.cursor()\n cursor.execute(drop_tables)\n queries = cursor.fetchall()\n for i in queries:\n cursor.execute(i[0])\n\n self.commit()\n self.__init__()","def drop_table_if_exists(self):\n\n return \"\"\"DROP TABLE IF EXISTS \"users\\\"\"\"\"","def drop_tables():\n commands = (\n \"\"\"\n DROP TABLE utilizador_partilha CASCADE\n \"\"\",\n \"\"\" \n DROP TABLE album CASCADE\n \"\"\",\n \"\"\"\n DROP TABLE compositores CASCADE\n \"\"\",\n \"\"\"\n DROP TABLE grupo CASCADE\n \"\"\",\n \"\"\"\n DROP TABLE letras_musica CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE playlist CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE editora CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE criticas CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE genero_musical CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE utilizador_partilha_criticas CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE utilizador_partilha_playlist CASCADE \n \"\"\",\n \"\"\"\n DROP TABLE album_genero_musical CASCADE\n \"\"\",\n \"\"\"\n DROP TABLE letras_musica_playlist CASCADE \n \"\"\")\n\n try:\n\n conn = psycopg2.connect(host=\"localhost\",database=\"SoundBox\", user=\"postgres\", password=\"postgres\")\n cur = conn.cursor()\n # DROP table one by one\n for command in commands:\n cur.execute(command)\n # close communication with the PostgreSQL database server\n cur.close()\n # commit the changes\n conn.commit()\n except (Exception, psycopg2.DatabaseError) as error:\n print(error)\n finally:\n if conn is not None:\n conn.close()","def drop_tables(session):\n \n for query in drop_table_queries:\n try:\n rows = session.execute(query)\n except Exception as e:\n print(e)","def drop_schema(self, schema):\n sql = f'set role {self.write_role}; ' \\\n + f'DROP SCHEMA IF EXISTS {schema};'\n return sql","def drop_database(cursor: Cursor, target: Union[Owner, str]) -> Result[str]:\n name = target if isinstance(target, str) else owner_name(target)\n result = pgsql.drop_database(cursor, name)\n result.value = name\n return result","def drop_table():\n\n try:\n sql = \"DROP TABLE IF EXISTS movies\"\n conn = psycopg2.connect(dsn=DB_DSN)\n cur = conn.cursor()\n cur.execute(sql)\n conn.commit()\n except psycopg2.Error as e:\n print e.message\n else:\n cur.close()\n conn.close()","def drop(self):\n cursor = self.connect.create_cursor()\n queries = (\n (\"USE dbPurBeurre\"),\n (\"SET foreign_key_checks = 0\"),\n (\"DROP TABLE IF EXISTS Asso_Prod_Cat\"),\n (\"DROP TABLE IF EXISTS Categories\"),\n (\"DROP TABLE IF EXISTS Produits\")\n )\n\n for query in queries:\n cursor.execute(query)","def pg_drop(ctx):\n ctx.obj = ConfigDBConnector()\n ctx.obj.connect()","def dropall_cmd():\n drop_all()\n print(\"all tables dropped\")","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()\n print(f\"\\nRunning: {query}\")","def get_sql_from_diff(self, **kwargs):\n gid = kwargs.get('gid')\n sid = kwargs.get('sid')\n did = kwargs.get('did')\n oid = kwargs.get('oid')\n data = kwargs.get('data', None)\n drop_sql = kwargs.get('drop_sql', False)\n\n if data:\n sql = self.get_sql(data=data, etid=oid)\n else:\n if drop_sql:\n sql = self.delete(gid=gid, sid=sid, did=did,\n etid=oid, only_sql=True)\n else:\n sql = self.sql(gid=gid, sid=sid, did=did, etid=oid,\n json_resp=False)\n return sql","def pack_for_drop(tables: tuple,\n ):\n\n return ';'.join([\"DROP TABLE IF EXISTS {}\".format(i) for i in tables])","def drop_table_if_exists(self, table): \n results = self.quick(\"DROP TABLE IF EXISTS {}\".format(table),context=\"MYDB\")","def drop_table(self, tablename):\n # print \"table dropped\"\n # return\n query = 'drop table ' + tablename\n try:\n self.__cur.execute(query)\n self.__conn.commit()\n except Exception as e:\n self.__conn.rollback()\n raise e","def postgres_drop(name=None, user=None):\n name = check(name, 'name: The dabatase name to create.')\n user = check(user, 'user: the user to grant privileges.')\n\n postgres_run((\n \"drop database if exists {name}\",\n \"drop role if exists {user}\"\n ), {'name': name, 'user': user})","def drop_table_in_HANA(colnames, table_name):\r\n cursor = hana.cursor()\r\n stmnt = 'drop table \\\"NIKOLAI\\\".\\\"'+table_name+'\\\"'\r\n print(stmnt)\r\n try:\r\n cursor.execute(stmnt)\r\n hana.commit()\r\n print(\"table dropped\")\r\n except:\r\n print(\"error in table dropping\")","def drop(self):\n c = self.cursor()\n for table in ['experiment','fact']:\n c.execute(\"drop table if exists {}\".format(table))\n self.commit()","def drop_tables(cur, conn): \n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def test_table_drop(app, runner):\n result = runner.invoke(drop_tables, input=\"y\")\n\n with app.app_context():\n assert not db.engine.has_table('link')\n assert not db.engine.has_table('user')","def drop_table(cls)->None:\n database.cursor.execute(\n \"DROP TABLE IF EXISTS {}\".format(cls.table_name))\n database.connection.commit()","def drop_tables (cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()\n print('All tables dropped.')","def drop_tables(cur, conn):\n \n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except Exception as e:\n print(e)","def is_dropping_database(queries, dbname):\n if dbname is None:\n return False\n\n def normalize_db_name(db):\n return db.lower().strip('`\"')\n\n dbname = normalize_db_name(dbname)\n\n for query in sqlparse.parse(queries):\n if query.get_name() is None:\n continue\n\n first_token = query.token_first(skip_cm=True)\n _, second_token = query.token_next(0, skip_cm=True)\n database_name = normalize_db_name(query.get_name())\n if (first_token.value.lower() == 'drop' and\n second_token.value.lower() in ('database', 'schema') and\n database_name == dbname):\n return True","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def db_drop(option):\r\n from flask_migrate import upgrade, migrate\r\n #from app.models import Role, User, Forecast\r\n \r\n print(\"option:\", option)\r\n\r\n engine=db.get_engine(app)\r\n \r\n \r\n if option == \"help\":\r\n print(\"db_drop [User|Role|Froecast|all]\")\r\n return True\r\n \r\n if option == \"User\":\r\n print(\"db_drop User()\")\r\n User.__table__.drop(engine)\r\n print(\"User.__table__.drop()\")\r\n \r\n if option == \"Role\":\r\n print(\"db_drop Role()\")\r\n Role.__table__.drop(engine)\r\n print(\"Role.__table__.drop()\")\r\n\r\n if option == \"Forecast\":\r\n print(\"db_drop Forecast()\")\r\n Forecast.__table__.drop(engine)\r\n print(\"Forecast.__table__.drop()\")\r\n\t\r\n if option == \"all\":\r\n print(\"db_drop all()\")\r\n db.drop_all()\r\n print(\"db.drop_all()\")\t\r\n \r\n upgrade()\r\n return True","def drop_table(self, table_name: str) -> None:\n sql = 'DROP TABLE IF EXISTS ' + table_name\n self.cursor.execute(sql)\n self.connection.commit()","def drop_tables(cur, conn) -> None:\n for query in drop_table_queries:\n cur.execute(query)\n conn.commit()","def _drop_tables(self):\n logging.info(\"Dropping all tables from the database!\")\n db_conn = self.engine.connect()\n query_result = list()\n query_result.append(db_conn.execute(\n \"DROP SCHEMA public CASCADE;CREATE SCHEMA public;\"))\n\n if self.database_choice == 'remote_database' or self.database_choice \\\n == 'remote_database_master':\n query_result.append(db_conn.execute('''\n GRANT ALL PRIVILEGES ON SCHEMA public TO housingcrud;\n GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO housingcrud;\n GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO housingcrud;\n GRANT ALL ON SCHEMA public TO public;\n '''))\n return query_result","def _postgres_remove():\n\n sql = []\n sql.append(f\"DROP FUNCTION IF EXISTS {fn_prefix}_history_id() CASCADE;\")\n sql.append(f\"DROP FUNCTION IF EXISTS {fn_prefix}_id() CASCADE;\")\n\n return sql","def dropTables(t=None):\n tablelist = tables.keys if t == None else [t]\n conn = getConnection()\n try:\n cur = conn.cursor()\n for table in tables.keys():\n query = \"DROP TABLE IF EXISTS %s;\" % table\n cur.execute(query)\n conn.commit()\n except Exception as ex:\n print(\"Failed to drop tables:\" )\n print(ex)\n sys.exit(1)","def drop_table(cursor, t_name): \n try:\n print(f\"Dropping table '{t_name}'...\")\n cursor.execute(f'DROP TABLE {t_name}')\n except mysql.connector.Error as err:\n if err.errno == 1051:\n print(f\"Table '{t_name}' DNE, moving on...\")\n pass\n else:\n print(str(err.errno) + \": \" + err.msg + \".\")\n exit(1)\n else:\n print(\"OK\")\n return None","def _drop(self, connection, query):\n try:\n connection.cursor().execute(query)\n connection.commit()\n return True\n except pymysql.InternalError as error:\n print(error.args[1])","def drop(drop_all=False):\n\n engine = current_app.extensions['meowth_dbutils'].db.engine\n if current_app.extensions['meowth_dbutils'].metadata.bind is None:\n current_app.extensions['meowth_dbutils'].metadata.bind = engine\n with perform(\n name='dbutils drop',\n before='Dropping all project tables',\n fail='Error occured while droping project tables',\n ):\n current_app.extensions['meowth_dbutils'].metadata.drop_all()\n with perform(\n name='dbutils drop',\n before='Dropping alembic versioning table',\n fail='Error occured while dropping alembic table',\n ):\n engine.execute('drop table if exists alembic_version')\n if drop_all:\n with perform(\n name='dbutils drop',\n before='Dropping all other tables in database',\n fail='Error occured while dropping other tables',\n ):\n current_app.extensions['meowth_dbutils'].db.reflect()\n current_app.extensions['meowth_dbutils'].db.drop_all()","def drop_tables(cur, conn):\n for query in drop_table_queries:\n try:\n cur.execute(query)\n conn.commit()\n except psycopg2.Error as e:\n print(\"Error: Could not drop table from query: {}\".format(query))\n print(e)","def help_drop(self):\n print(DROP)","def mysql_drop(name=None, user=None, db_password=None):\n name = check(name, 'name: the database name to delete.')\n user = check(user, 'user: the user to remove.')\n password = check(password, 'password: user\\'s password')\n host = check(host, 'host: machine ', default='localhost')\n db_password = check(db_password, 'db_password: mysql password.')\n port == ':'+port if port is not '' else ''\n\n mysql_run((\n \"DROP DATABASE IF EXISTS {name}\",\n \"DROP USER {user}\",\n ), {'name': name, 'user': user, 'password': password, 'host': host,\n 'port': port}, db_password=db_password)","def drop_db(code, confirm_by_typing_db_code_again=None):\n params = {\"confirm_by_typing_db_code_again\": confirm_by_typing_db_code_again}\n response = houston.delete(\"/history/databases/{0}\".format(code), params=params)\n houston.raise_for_status_with_json(response)\n return response.json()","def drop_database_tables(cls):\n cursor = Database.connect_to_db()\n # drop users table\n sql_command = \"\"\" DROP TABLE IF EXISTS users CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop parties table\n sql_command = \"\"\" DROP TABLE IF EXISTS parties CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop offices table\n sql_command = \"\"\" DROP TABLE IF EXISTS offices CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop candidates table\n sql_command = \"\"\" DROP TABLE IF EXISTS candidates CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop votes table\n sql_command = \"\"\" DROP TABLE IF EXISTS votes CASCADE;\n \"\"\"\n cursor.execute(sql_command)\n # drop applications table\n sql_command = \"\"\" DROP TABLE IF EXISTS applications CASCADE;\n \"\"\"\n cursor.execute(sql_command)","def drop_entity(self, entity):\n conn = self._connect(entity)\n try:\n cursor = conn.cursor()\n cursor.executescript(f\"DROP TABLE [{entity.code}];\")\n finally:\n conn.close()","def sqlite3_simple_delete_table(data_base, table):\n con = sqlite3.connect(data_base)\n cur = con.cursor()\n query = 'DROP TABLE IF EXISTS ' + table\n cur.execute(query)\n cur.close()\n con.close()","def delete_table(conn):\n try:\n cur = conn.cursor()\n cur.execute(\"DROP TABLE users;\")\n except Error as e:\n print(e)","def dropTable(self, table):\n\n self.__open()\n query = \"DROP TABLE {}\".format(table)\n self.__cursor.execute(query)\n self.__close()","def drop_schema(self, name):\n self._connection.execute_nonquery(\n \"sql\", _DROP_DATABASE_QUERY.format(quote_identifier(name)), True\n )","def drop_table_if_exists():\n drop_users_table = \"\"\"\n DROP TABLE IF EXISTS users CASCADE\"\"\"\n drop_parties_table = \"\"\"\n DROP TABLE IF EXISTS parties CASCADE\"\"\"\n drop_offices_table = \"\"\"\n DROP TABLE IF EXISTS offices CASCADE\"\"\"\n drop_candidates_table = \"\"\"\n DROP TABLE IF EXISTS candidates CASCADE\"\"\"\n\n drop_voters_table = \"\"\"\n DROP TABLE IF EXISTS votes CASCADE\"\"\"\n return [drop_users_table, drop_parties_table, drop_offices_table,\n drop_candidates_table, drop_voters_table]","def delete(self, sql):\n try:\n # Execute the SQL command\n self.cursor.execute(sql)\n # Commit your changes in the database\n self.db.commit()\n except:\n # Rollback in case there is any error\n self.db.rollback()","def create_delete_code(name_of_table, where_col = None, where_equals_value = None):\n sql_str = ''\n try:\n if where_col is None or where_equals_value is None:\n raise Exception('You must provide a where column and an equals value')\n else:\n sql_str = 'DELETE FROM ' + str(name_of_table).strip()\n sql_str += '\\nWHERE ' + where_col + \" = \" + str(where_equals_value).strip()\n except Exception as e:\n raise Exception('Error in create_delete_code(): ' + e.__str__())\n return sql_str","def ddl_text_from_delta_command(delta):\n if isinstance(delta, s_db.AlterDatabase):\n commands = delta\n else:\n commands = [delta]\n\n text = []\n for command in commands:\n delta_ast = ddl_from_delta(command)\n if delta_ast:\n stmt_text = edgeql.generate_source(edgeql.optimize(\n delta_ast, strip_builtins=False))\n text.append(stmt_text + ';')\n\n return '\\n'.join(text)","def drop_database():\n drop_db(app)","def dropTable(self, in_table_name):\n self.cursor.execute('DROP TABLE {};'.format(in_table_name))\n self.connection.commit()","def drop_db():\n database.db.reflect()\n database.db.drop_all()\n print('Dropped the database')","def drop_tables():\n drop_table(ShoppingList)\n drop_table(User)\n drop_table(Category)","def drop():\n if prompt_bool(\"Are you sure you want to lose all your data\"):\n db.drop_all()\n db.engine.execute(\"drop table if exists alembic_version\")","def test_drop_table(self):\n schema: t.List[DiffableTable] = []\n schema_snapshot: t.List[DiffableTable] = [\n DiffableTable(class_name=\"Band\", tablename=\"band\", columns=[])\n ]\n schema_differ = SchemaDiffer(\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\"y\"\n )\n\n self.assertTrue(len(schema_differ.drop_tables.statements) == 1)\n self.assertEqual(\n schema_differ.drop_tables.statements[0],\n \"manager.drop_table(class_name='Band', tablename='band')\",\n )","def droptables(db, cursor):\n cursor.execute('''DROP TABLE IF EXISTS worlds;''')\n cursor.execute('''DROP TABLE IF EXISTS characters''')\n cursor.execute('''DROP TABLE IF EXISTS chardata''')\n db.commit()","def deleteTable(self, name: str, line, column):\n database = SymbolTable().useDatabase\n if not database:\n desc = f\": Database not selected\"\n ErrorController().add(4, 'Execution', desc,\n line, column)\n return\n dbStatement = data_mode.mode(\n database.mode).dropTable(database.name.lower(), name.lower())\n\n if dbStatement == 0:\n table = self.searchTable(database, name)\n database.tables.remove(table)\n self.writeFile()\n DataWindow().consoleText('Query returned successfully: Table deleted')\n\n elif dbStatement == 1:\n desc = f\": Can't drop table {name}\"\n ErrorController().add(34, 'Execution', desc, line, column)\n\n elif dbStatement == 2:\n desc = f\": Database {database.name} does not exist\"\n ErrorController().add(35, 'Execution', desc, line, column)\n\n elif dbStatement == 3:\n desc = f\": Table {name} does not exist\"\n ErrorController().add(27, 'Execution', desc, line, column)","def bulk_drop_table(cursor, t_name_list):\n for t_name in t_name_list:\n try:\n print(f\"Dropping table '{t_name}'...\")\n cursor.execute(f'DROP TABLE {t_name}')\n except mysql.connector.Error as err:\n if err.errno == 1051:\n print(f\"Table '{t_name}' DNE, moving on...\")\n pass\n else:\n print(str(err.errno) + \": \" + err.msg+\".\")\n exit(1)\n else:\n print(\"OK\")\n return None","def drop_table(self, name):\n if not self._open:\n raise ValueError(\"Operation on closed store\")\n\n table_grp = self.grp[name]\n if isinstance(table_grp, self.GROUP_TYPE) and all(\n isinstance(k, self.ARRAY_TYPE) for k in table_grp.values()\n ):\n table_name = table_grp.name\n if table_name == \"/\":\n for colname in self.grp.keys():\n self.delcol(table_grp, colname)\n else:\n del self.grp[name]","def cvv_ttype_drop(argv):\n p = optparse.OptionParser()\n p.add_option('-d', '--debug',\n action='store_true', default=False, dest='debug',\n help='run the debugger')\n try:\n (o, a) = p.parse_args(argv)\n except SystemExit:\n return\n\n if o.debug:\n pdb.set_trace()\n\n result = dbschem.alter_table(table=\"checkables\", dropcol=\"ttypes\")\n print(result)","def test_drop_table(fs: FakeFilesystem) -> None:\n fs.create_file(\"test.csv\", contents=CONTENTS)\n\n connection = connect(\":memory:\", [\"csvfile\"])\n cursor = connection.cursor()\n\n sql = 'DROP TABLE \"test.csv\"'\n cursor.execute(sql)\n assert not Path(\"test.csv\").exists()","def drop_tables() -> None:\n print(\"Dropping database tables using SQLAlchemy ORM\")\n Base.metadata.drop_all(engine)\n print(\"Done dropping tables\")","def _drop(self):\n stmts = []\n for ext in self:\n if hasattr(self[ext], 'dropped'):\n stmts.append(self[ext].drop())\n return stmts","def _drop_db(keep_tables=None):\n server.db.session.remove()\n if keep_tables is None:\n keep_tables = []\n meta = server.db.metadata\n for table in reversed(meta.sorted_tables):\n if table.name in keep_tables:\n continue\n server.db.session.execute(table.delete())\n server.db.session.commit()","def test_drop_table(self):\n session = self.prepare(user_table=True)\n\n result = list(session.execute((\"SELECT * FROM system_schema.views \"\n \"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\")))\n assert len(result) == 1, \"Expecting {} materialized view, got {}\".format(1, len(result))\n\n assert_invalid(\n session,\n \"DROP TABLE ks.users;\",\n \"Cannot drop table when materialized views still depend on it\"\n )\n\n result = list(session.execute((\"SELECT * FROM system_schema.views \"\n \"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\")))\n assert len(result) == 1, \"Expecting {} materialized view, got {}\".format(1, len(result))\n\n session.execute(\"DROP MATERIALIZED VIEW ks.users_by_state;\")\n session.execute(\"DROP TABLE ks.users;\")\n\n result = list(session.execute((\"SELECT * FROM system_schema.views \"\n \"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\")))\n assert len(result) == 0, \"Expecting {} materialized view, got {}\".format(1, len(result))","def test_drop_table(pawprint_default_tracker_db_with_table):\n\n tracker = pawprint_default_tracker_db_with_table\n\n # make sure table exists\n with pytest.raises(ProgrammingError):\n tracker.create_table()\n\n tracker.drop_table()\n\n with pytest.raises(ProgrammingError):\n tracker.drop_table()","def drop_db(self, dbname):\n if dbname in self.list_dbs():\n return self.delete(dbname).text\n else:\n raise NotExistingDatabase(dbname)","def dropTable(self, schema, table, cascade=False):\r\n if cascade:\r\n return self.runSql('DROP TABLE IF EXISTS {} CASCADE'.format(self.encodeTableName(schema, table)))\r\n else:\r\n return self.runSql('DROP TABLE IF EXISTS {}'.format(self.encodeTableName(schema, table)))","def drop_tables(self):\n with sql.connect('./{}.db'.format(self.name)) as conn:\n conn.execute(\"DROP TABLE tweets\")\n conn.execute(\"DROP TABLE tweet_peaks\")","def delete_table(self, table_name):\n try:\n conn = self.engine.connect()\n conn.execute(\"DROP table \" + table_name)\n print(\"-I- Deleted table \" + table_name)\n except Exception as e:\n print(\"-W- \" + str(e))","def removedb(dbname):\n os.system(\"dropdb %s\" % dbname)","def Drop_Tables_From_DB(self, tables_list, d_params=None):\n ctx = self.__Connect_To_Snowflake(d_params)\n if len(tables_list) > 0:\n for table in tables_list:\n try:\n ctx.cursor().execute(f\"drop table {table};\")\n print(f\"Deleted : {table}\")\n except:\n print(f\"Doesn't exist : {table}\")\n ctx.close()\n return None"],"string":"[\n \"def drop(name):\\n\\t\\treturn \\\"DROP DATABASE {0};\\\".format(name)\",\n \"def _get_sql_drop_table(table_attr):\\n template = 'DROP TABLE IF EXISTS \\\"%s\\\" CASCADE;' % (table_attr['name'])\\n return template\",\n \"def drop_statement(self, objecttype, objectname):\\n statement = Engine.drop_statement(self, objecttype, objectname)\\n statement += \\\" CASCADE;\\\"\\n return statement.replace(\\\" DATABASE \\\", \\\" SCHEMA \\\")\",\n \"def drop_table(self):\\n\\n return \\\"\\\"\\\"DROP TABLE \\\"users\\\\\\\"\\\"\\\"\\\"\",\n \"def drop_table(self, schema, table):\\n sql = f'set role {self.write_role}; ' \\\\\\n + f'DROP TABLE IF EXISTS {schema}.{table};'\\n return sql\",\n \"def drop_table(conn, drop_table_sql):\\n try:\\n c = conn.cursor()\\n c.execute(drop_table_sql)\\n except Error as e:\\n print(e)\",\n \"def drop_table(database, table):\\n sql = \\\"\\\"\\\"DROP TABLE %s\\\"\\\"\\\" % table\\n print \\\"Dropping Table %s from the Database %s\\\" % (table, database)\\n execute_and_commit_sql(database, sql)\\n return None\",\n \"def drop_table(self):\\n sql = 'DROP TABLE {}'.format(self.TABLE_NAME)\\n yield self._pool.execute(sql)\",\n \"def drop_table(self, table_name):\\n drop_command = \\\"DROP TABLE {}\\\".format(table_name)\\n try:\\n self.cursor.execute(drop_command)\\n status = 'Table {} dropped'.format(table_name)\\n except p.Error as exception:\\n status = 'Exception occured in drop_table()'\\n print(exception.pgerror)\",\n \"def dropTable(self,table):\\n query = \\\"DROP TABLE \\\"+table\\n\\tcur = self.db.cursor()\\n\\ttry:\\n\\t iQuery = self.updateLog(query)\\n\\t cur.execute(iQuery)\\n# self.cursor.execute(iQuery)\\n\\texcept:\\n\\t self.log.write(\\\"No %s table found\\\\n\\\"%table)\\n\\tcur.close()\",\n \"def get_drop(s):\\n s = match_token(s, 'DROP')\\n s = match_token(s, 'ROLLUP')\\n s = match_token(s, 'VIEW')\\n s, rollup_view_name = get_token(s)\\n t = drop_rollup_str(rollup_view_name)\\n return (s, t)\",\n \"def drop_created_table(opts, stats):\\n print(\\\"--------------------------------------\\\")\\n print(\\\"Dropping created table %s\\\" % (opts.table_name, ))\\n print(\\\"--------------------------------------\\\")\\n print(timestamp())\\n sql = \\\"DROP TABLE %s\\\" % (opts.table_name, )\\n cmd = 'echo \\\"%s\\\" | impala-shell -i %s -f -' % (sql, opts.impalad_address)\\n run_command(opts, cmd)\",\n \"def as_sql(self):\\r\\n assert len(self.query.tables) == 1, \\\\\\r\\n \\\"Can only delete from one table at a time.\\\"\\r\\n qn = self.quote_name_unless_alias\\r\\n #=======================================================================\\r\\n # self._hasConstraints(self.query.tables[0])\\r\\n #=======================================================================\\r\\n \\r\\n result = ['DELETE FROM %s' % qn(self.query.tables[0])]\\r\\n where, params = self.query.where.as_sql(qn=qn, connection=self.connection)\\r\\n if where:\\r\\n result.append('WHERE %s' % where)\\r\\n ##DOTO: Delete after test\\r\\n #=======================================================================\\r\\n # print '>>>',result,params\\r\\n # if result[0] == 'DELETE FROM \\\"django_flatpage_sites\\\"' :\\r\\n # import pdb; pdb.set_trace()\\r\\n #=======================================================================\\r\\n return ' '.join(result), tuple(params)\",\n \"def drop_tables(session):\\n\\n for query in drop_table_queries:\\n session.execute(query)\",\n \"def drop(self, alter_table=True):\\n if self.name == 'PRIMARY':\\n return \\\"DROP PRIMARY KEY\\\"\\n elif alter_table:\\n return \\\"DROP INDEX `%s`\\\" % (self.name)\\n else:\\n return \\\"DROP INDEX `%s` ON `%s`\\\" % (self.name, self.parent.name)\",\n \"async def _delete_stmt(self):\\n return \\\"DELETE FROM {} WHERE {}=$1\\\".format(self.table,\\n self.identifier_key)\",\n \"def drop_table(cls):\\n if not connection.connected:\\n raise Exception('Not connected to the database.')\\n sql = u'DROP TABLE IF EXISTS %s' % cls.table()\\n connection.execute(sql)\",\n \"def table_drop(self, table):\\n\\n stmt = 'DROP TABLE %s' % table\\n\\n curs = self.cursor()\\n try:\\n curs.execute(stmt)\\n except sqlite3.OperationalError:\\n pass\\n finally:\\n curs.close()\",\n \"def test_drop(self):\\n my_conn = MySQL(*self.conn_params)\\n sql = \\\"CREATE TABLE table1 (id integer, column1 varchar(100), \\\" \\\\\\n \\\"column2 double)\\\"\\n my_conn.execute(sql)\\n my_conn.get_table('table1')\\n my_conn.drop('table1') # DROP example\\n with self.assertRaises(InvalidRequestError):\\n my_conn.get_table('table1')\",\n \"def drop_tables(session):\\n for query in drop_table_queries:\\n session.execute(query)\",\n \"def drop(self):\\n self.__init__()\\n cursor = self.connection.cursor()\\n cursor.execute(drop_tables)\\n queries = cursor.fetchall()\\n for i in queries:\\n cursor.execute(i[0])\\n\\n self.commit()\\n self.__init__()\",\n \"def drop_table_if_exists(self):\\n\\n return \\\"\\\"\\\"DROP TABLE IF EXISTS \\\"users\\\\\\\"\\\"\\\"\\\"\",\n \"def drop_tables():\\n commands = (\\n \\\"\\\"\\\"\\n DROP TABLE utilizador_partilha CASCADE\\n \\\"\\\"\\\",\\n \\\"\\\"\\\" \\n DROP TABLE album CASCADE\\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE compositores CASCADE\\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE grupo CASCADE\\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE letras_musica CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE playlist CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE editora CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE criticas CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE genero_musical CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE utilizador_partilha_criticas CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE utilizador_partilha_playlist CASCADE \\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE album_genero_musical CASCADE\\n \\\"\\\"\\\",\\n \\\"\\\"\\\"\\n DROP TABLE letras_musica_playlist CASCADE \\n \\\"\\\"\\\")\\n\\n try:\\n\\n conn = psycopg2.connect(host=\\\"localhost\\\",database=\\\"SoundBox\\\", user=\\\"postgres\\\", password=\\\"postgres\\\")\\n cur = conn.cursor()\\n # DROP table one by one\\n for command in commands:\\n cur.execute(command)\\n # close communication with the PostgreSQL database server\\n cur.close()\\n # commit the changes\\n conn.commit()\\n except (Exception, psycopg2.DatabaseError) as error:\\n print(error)\\n finally:\\n if conn is not None:\\n conn.close()\",\n \"def drop_tables(session):\\n \\n for query in drop_table_queries:\\n try:\\n rows = session.execute(query)\\n except Exception as e:\\n print(e)\",\n \"def drop_schema(self, schema):\\n sql = f'set role {self.write_role}; ' \\\\\\n + f'DROP SCHEMA IF EXISTS {schema};'\\n return sql\",\n \"def drop_database(cursor: Cursor, target: Union[Owner, str]) -> Result[str]:\\n name = target if isinstance(target, str) else owner_name(target)\\n result = pgsql.drop_database(cursor, name)\\n result.value = name\\n return result\",\n \"def drop_table():\\n\\n try:\\n sql = \\\"DROP TABLE IF EXISTS movies\\\"\\n conn = psycopg2.connect(dsn=DB_DSN)\\n cur = conn.cursor()\\n cur.execute(sql)\\n conn.commit()\\n except psycopg2.Error as e:\\n print e.message\\n else:\\n cur.close()\\n conn.close()\",\n \"def drop(self):\\n cursor = self.connect.create_cursor()\\n queries = (\\n (\\\"USE dbPurBeurre\\\"),\\n (\\\"SET foreign_key_checks = 0\\\"),\\n (\\\"DROP TABLE IF EXISTS Asso_Prod_Cat\\\"),\\n (\\\"DROP TABLE IF EXISTS Categories\\\"),\\n (\\\"DROP TABLE IF EXISTS Produits\\\")\\n )\\n\\n for query in queries:\\n cursor.execute(query)\",\n \"def pg_drop(ctx):\\n ctx.obj = ConfigDBConnector()\\n ctx.obj.connect()\",\n \"def dropall_cmd():\\n drop_all()\\n print(\\\"all tables dropped\\\")\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\\n print(f\\\"\\\\nRunning: {query}\\\")\",\n \"def get_sql_from_diff(self, **kwargs):\\n gid = kwargs.get('gid')\\n sid = kwargs.get('sid')\\n did = kwargs.get('did')\\n oid = kwargs.get('oid')\\n data = kwargs.get('data', None)\\n drop_sql = kwargs.get('drop_sql', False)\\n\\n if data:\\n sql = self.get_sql(data=data, etid=oid)\\n else:\\n if drop_sql:\\n sql = self.delete(gid=gid, sid=sid, did=did,\\n etid=oid, only_sql=True)\\n else:\\n sql = self.sql(gid=gid, sid=sid, did=did, etid=oid,\\n json_resp=False)\\n return sql\",\n \"def pack_for_drop(tables: tuple,\\n ):\\n\\n return ';'.join([\\\"DROP TABLE IF EXISTS {}\\\".format(i) for i in tables])\",\n \"def drop_table_if_exists(self, table): \\n results = self.quick(\\\"DROP TABLE IF EXISTS {}\\\".format(table),context=\\\"MYDB\\\")\",\n \"def drop_table(self, tablename):\\n # print \\\"table dropped\\\"\\n # return\\n query = 'drop table ' + tablename\\n try:\\n self.__cur.execute(query)\\n self.__conn.commit()\\n except Exception as e:\\n self.__conn.rollback()\\n raise e\",\n \"def postgres_drop(name=None, user=None):\\n name = check(name, 'name: The dabatase name to create.')\\n user = check(user, 'user: the user to grant privileges.')\\n\\n postgres_run((\\n \\\"drop database if exists {name}\\\",\\n \\\"drop role if exists {user}\\\"\\n ), {'name': name, 'user': user})\",\n \"def drop_table_in_HANA(colnames, table_name):\\r\\n cursor = hana.cursor()\\r\\n stmnt = 'drop table \\\\\\\"NIKOLAI\\\\\\\".\\\\\\\"'+table_name+'\\\\\\\"'\\r\\n print(stmnt)\\r\\n try:\\r\\n cursor.execute(stmnt)\\r\\n hana.commit()\\r\\n print(\\\"table dropped\\\")\\r\\n except:\\r\\n print(\\\"error in table dropping\\\")\",\n \"def drop(self):\\n c = self.cursor()\\n for table in ['experiment','fact']:\\n c.execute(\\\"drop table if exists {}\\\".format(table))\\n self.commit()\",\n \"def drop_tables(cur, conn): \\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def test_table_drop(app, runner):\\n result = runner.invoke(drop_tables, input=\\\"y\\\")\\n\\n with app.app_context():\\n assert not db.engine.has_table('link')\\n assert not db.engine.has_table('user')\",\n \"def drop_table(cls)->None:\\n database.cursor.execute(\\n \\\"DROP TABLE IF EXISTS {}\\\".format(cls.table_name))\\n database.connection.commit()\",\n \"def drop_tables (cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\\n print('All tables dropped.')\",\n \"def drop_tables(cur, conn):\\n \\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except Exception as e:\\n print(e)\",\n \"def is_dropping_database(queries, dbname):\\n if dbname is None:\\n return False\\n\\n def normalize_db_name(db):\\n return db.lower().strip('`\\\"')\\n\\n dbname = normalize_db_name(dbname)\\n\\n for query in sqlparse.parse(queries):\\n if query.get_name() is None:\\n continue\\n\\n first_token = query.token_first(skip_cm=True)\\n _, second_token = query.token_next(0, skip_cm=True)\\n database_name = normalize_db_name(query.get_name())\\n if (first_token.value.lower() == 'drop' and\\n second_token.value.lower() in ('database', 'schema') and\\n database_name == dbname):\\n return True\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def db_drop(option):\\r\\n from flask_migrate import upgrade, migrate\\r\\n #from app.models import Role, User, Forecast\\r\\n \\r\\n print(\\\"option:\\\", option)\\r\\n\\r\\n engine=db.get_engine(app)\\r\\n \\r\\n \\r\\n if option == \\\"help\\\":\\r\\n print(\\\"db_drop [User|Role|Froecast|all]\\\")\\r\\n return True\\r\\n \\r\\n if option == \\\"User\\\":\\r\\n print(\\\"db_drop User()\\\")\\r\\n User.__table__.drop(engine)\\r\\n print(\\\"User.__table__.drop()\\\")\\r\\n \\r\\n if option == \\\"Role\\\":\\r\\n print(\\\"db_drop Role()\\\")\\r\\n Role.__table__.drop(engine)\\r\\n print(\\\"Role.__table__.drop()\\\")\\r\\n\\r\\n if option == \\\"Forecast\\\":\\r\\n print(\\\"db_drop Forecast()\\\")\\r\\n Forecast.__table__.drop(engine)\\r\\n print(\\\"Forecast.__table__.drop()\\\")\\r\\n\\t\\r\\n if option == \\\"all\\\":\\r\\n print(\\\"db_drop all()\\\")\\r\\n db.drop_all()\\r\\n print(\\\"db.drop_all()\\\")\\t\\r\\n \\r\\n upgrade()\\r\\n return True\",\n \"def drop_table(self, table_name: str) -> None:\\n sql = 'DROP TABLE IF EXISTS ' + table_name\\n self.cursor.execute(sql)\\n self.connection.commit()\",\n \"def drop_tables(cur, conn) -> None:\\n for query in drop_table_queries:\\n cur.execute(query)\\n conn.commit()\",\n \"def _drop_tables(self):\\n logging.info(\\\"Dropping all tables from the database!\\\")\\n db_conn = self.engine.connect()\\n query_result = list()\\n query_result.append(db_conn.execute(\\n \\\"DROP SCHEMA public CASCADE;CREATE SCHEMA public;\\\"))\\n\\n if self.database_choice == 'remote_database' or self.database_choice \\\\\\n == 'remote_database_master':\\n query_result.append(db_conn.execute('''\\n GRANT ALL PRIVILEGES ON SCHEMA public TO housingcrud;\\n GRANT ALL PRIVILEGES ON ALL TABLES IN SCHEMA public TO housingcrud;\\n GRANT ALL PRIVILEGES ON ALL SEQUENCES IN SCHEMA public TO housingcrud;\\n GRANT ALL ON SCHEMA public TO public;\\n '''))\\n return query_result\",\n \"def _postgres_remove():\\n\\n sql = []\\n sql.append(f\\\"DROP FUNCTION IF EXISTS {fn_prefix}_history_id() CASCADE;\\\")\\n sql.append(f\\\"DROP FUNCTION IF EXISTS {fn_prefix}_id() CASCADE;\\\")\\n\\n return sql\",\n \"def dropTables(t=None):\\n tablelist = tables.keys if t == None else [t]\\n conn = getConnection()\\n try:\\n cur = conn.cursor()\\n for table in tables.keys():\\n query = \\\"DROP TABLE IF EXISTS %s;\\\" % table\\n cur.execute(query)\\n conn.commit()\\n except Exception as ex:\\n print(\\\"Failed to drop tables:\\\" )\\n print(ex)\\n sys.exit(1)\",\n \"def drop_table(cursor, t_name): \\n try:\\n print(f\\\"Dropping table '{t_name}'...\\\")\\n cursor.execute(f'DROP TABLE {t_name}')\\n except mysql.connector.Error as err:\\n if err.errno == 1051:\\n print(f\\\"Table '{t_name}' DNE, moving on...\\\")\\n pass\\n else:\\n print(str(err.errno) + \\\": \\\" + err.msg + \\\".\\\")\\n exit(1)\\n else:\\n print(\\\"OK\\\")\\n return None\",\n \"def _drop(self, connection, query):\\n try:\\n connection.cursor().execute(query)\\n connection.commit()\\n return True\\n except pymysql.InternalError as error:\\n print(error.args[1])\",\n \"def drop(drop_all=False):\\n\\n engine = current_app.extensions['meowth_dbutils'].db.engine\\n if current_app.extensions['meowth_dbutils'].metadata.bind is None:\\n current_app.extensions['meowth_dbutils'].metadata.bind = engine\\n with perform(\\n name='dbutils drop',\\n before='Dropping all project tables',\\n fail='Error occured while droping project tables',\\n ):\\n current_app.extensions['meowth_dbutils'].metadata.drop_all()\\n with perform(\\n name='dbutils drop',\\n before='Dropping alembic versioning table',\\n fail='Error occured while dropping alembic table',\\n ):\\n engine.execute('drop table if exists alembic_version')\\n if drop_all:\\n with perform(\\n name='dbutils drop',\\n before='Dropping all other tables in database',\\n fail='Error occured while dropping other tables',\\n ):\\n current_app.extensions['meowth_dbutils'].db.reflect()\\n current_app.extensions['meowth_dbutils'].db.drop_all()\",\n \"def drop_tables(cur, conn):\\n for query in drop_table_queries:\\n try:\\n cur.execute(query)\\n conn.commit()\\n except psycopg2.Error as e:\\n print(\\\"Error: Could not drop table from query: {}\\\".format(query))\\n print(e)\",\n \"def help_drop(self):\\n print(DROP)\",\n \"def mysql_drop(name=None, user=None, db_password=None):\\n name = check(name, 'name: the database name to delete.')\\n user = check(user, 'user: the user to remove.')\\n password = check(password, 'password: user\\\\'s password')\\n host = check(host, 'host: machine ', default='localhost')\\n db_password = check(db_password, 'db_password: mysql password.')\\n port == ':'+port if port is not '' else ''\\n\\n mysql_run((\\n \\\"DROP DATABASE IF EXISTS {name}\\\",\\n \\\"DROP USER {user}\\\",\\n ), {'name': name, 'user': user, 'password': password, 'host': host,\\n 'port': port}, db_password=db_password)\",\n \"def drop_db(code, confirm_by_typing_db_code_again=None):\\n params = {\\\"confirm_by_typing_db_code_again\\\": confirm_by_typing_db_code_again}\\n response = houston.delete(\\\"/history/databases/{0}\\\".format(code), params=params)\\n houston.raise_for_status_with_json(response)\\n return response.json()\",\n \"def drop_database_tables(cls):\\n cursor = Database.connect_to_db()\\n # drop users table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS users CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\\n # drop parties table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS parties CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\\n # drop offices table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS offices CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\\n # drop candidates table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS candidates CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\\n # drop votes table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS votes CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\\n # drop applications table\\n sql_command = \\\"\\\"\\\" DROP TABLE IF EXISTS applications CASCADE;\\n \\\"\\\"\\\"\\n cursor.execute(sql_command)\",\n \"def drop_entity(self, entity):\\n conn = self._connect(entity)\\n try:\\n cursor = conn.cursor()\\n cursor.executescript(f\\\"DROP TABLE [{entity.code}];\\\")\\n finally:\\n conn.close()\",\n \"def sqlite3_simple_delete_table(data_base, table):\\n con = sqlite3.connect(data_base)\\n cur = con.cursor()\\n query = 'DROP TABLE IF EXISTS ' + table\\n cur.execute(query)\\n cur.close()\\n con.close()\",\n \"def delete_table(conn):\\n try:\\n cur = conn.cursor()\\n cur.execute(\\\"DROP TABLE users;\\\")\\n except Error as e:\\n print(e)\",\n \"def dropTable(self, table):\\n\\n self.__open()\\n query = \\\"DROP TABLE {}\\\".format(table)\\n self.__cursor.execute(query)\\n self.__close()\",\n \"def drop_schema(self, name):\\n self._connection.execute_nonquery(\\n \\\"sql\\\", _DROP_DATABASE_QUERY.format(quote_identifier(name)), True\\n )\",\n \"def drop_table_if_exists():\\n drop_users_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS users CASCADE\\\"\\\"\\\"\\n drop_parties_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS parties CASCADE\\\"\\\"\\\"\\n drop_offices_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS offices CASCADE\\\"\\\"\\\"\\n drop_candidates_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS candidates CASCADE\\\"\\\"\\\"\\n\\n drop_voters_table = \\\"\\\"\\\"\\n DROP TABLE IF EXISTS votes CASCADE\\\"\\\"\\\"\\n return [drop_users_table, drop_parties_table, drop_offices_table,\\n drop_candidates_table, drop_voters_table]\",\n \"def delete(self, sql):\\n try:\\n # Execute the SQL command\\n self.cursor.execute(sql)\\n # Commit your changes in the database\\n self.db.commit()\\n except:\\n # Rollback in case there is any error\\n self.db.rollback()\",\n \"def create_delete_code(name_of_table, where_col = None, where_equals_value = None):\\n sql_str = ''\\n try:\\n if where_col is None or where_equals_value is None:\\n raise Exception('You must provide a where column and an equals value')\\n else:\\n sql_str = 'DELETE FROM ' + str(name_of_table).strip()\\n sql_str += '\\\\nWHERE ' + where_col + \\\" = \\\" + str(where_equals_value).strip()\\n except Exception as e:\\n raise Exception('Error in create_delete_code(): ' + e.__str__())\\n return sql_str\",\n \"def ddl_text_from_delta_command(delta):\\n if isinstance(delta, s_db.AlterDatabase):\\n commands = delta\\n else:\\n commands = [delta]\\n\\n text = []\\n for command in commands:\\n delta_ast = ddl_from_delta(command)\\n if delta_ast:\\n stmt_text = edgeql.generate_source(edgeql.optimize(\\n delta_ast, strip_builtins=False))\\n text.append(stmt_text + ';')\\n\\n return '\\\\n'.join(text)\",\n \"def drop_database():\\n drop_db(app)\",\n \"def dropTable(self, in_table_name):\\n self.cursor.execute('DROP TABLE {};'.format(in_table_name))\\n self.connection.commit()\",\n \"def drop_db():\\n database.db.reflect()\\n database.db.drop_all()\\n print('Dropped the database')\",\n \"def drop_tables():\\n drop_table(ShoppingList)\\n drop_table(User)\\n drop_table(Category)\",\n \"def drop():\\n if prompt_bool(\\\"Are you sure you want to lose all your data\\\"):\\n db.drop_all()\\n db.engine.execute(\\\"drop table if exists alembic_version\\\")\",\n \"def test_drop_table(self):\\n schema: t.List[DiffableTable] = []\\n schema_snapshot: t.List[DiffableTable] = [\\n DiffableTable(class_name=\\\"Band\\\", tablename=\\\"band\\\", columns=[])\\n ]\\n schema_differ = SchemaDiffer(\\n schema=schema, schema_snapshot=schema_snapshot, auto_input=\\\"y\\\"\\n )\\n\\n self.assertTrue(len(schema_differ.drop_tables.statements) == 1)\\n self.assertEqual(\\n schema_differ.drop_tables.statements[0],\\n \\\"manager.drop_table(class_name='Band', tablename='band')\\\",\\n )\",\n \"def droptables(db, cursor):\\n cursor.execute('''DROP TABLE IF EXISTS worlds;''')\\n cursor.execute('''DROP TABLE IF EXISTS characters''')\\n cursor.execute('''DROP TABLE IF EXISTS chardata''')\\n db.commit()\",\n \"def deleteTable(self, name: str, line, column):\\n database = SymbolTable().useDatabase\\n if not database:\\n desc = f\\\": Database not selected\\\"\\n ErrorController().add(4, 'Execution', desc,\\n line, column)\\n return\\n dbStatement = data_mode.mode(\\n database.mode).dropTable(database.name.lower(), name.lower())\\n\\n if dbStatement == 0:\\n table = self.searchTable(database, name)\\n database.tables.remove(table)\\n self.writeFile()\\n DataWindow().consoleText('Query returned successfully: Table deleted')\\n\\n elif dbStatement == 1:\\n desc = f\\\": Can't drop table {name}\\\"\\n ErrorController().add(34, 'Execution', desc, line, column)\\n\\n elif dbStatement == 2:\\n desc = f\\\": Database {database.name} does not exist\\\"\\n ErrorController().add(35, 'Execution', desc, line, column)\\n\\n elif dbStatement == 3:\\n desc = f\\\": Table {name} does not exist\\\"\\n ErrorController().add(27, 'Execution', desc, line, column)\",\n \"def bulk_drop_table(cursor, t_name_list):\\n for t_name in t_name_list:\\n try:\\n print(f\\\"Dropping table '{t_name}'...\\\")\\n cursor.execute(f'DROP TABLE {t_name}')\\n except mysql.connector.Error as err:\\n if err.errno == 1051:\\n print(f\\\"Table '{t_name}' DNE, moving on...\\\")\\n pass\\n else:\\n print(str(err.errno) + \\\": \\\" + err.msg+\\\".\\\")\\n exit(1)\\n else:\\n print(\\\"OK\\\")\\n return None\",\n \"def drop_table(self, name):\\n if not self._open:\\n raise ValueError(\\\"Operation on closed store\\\")\\n\\n table_grp = self.grp[name]\\n if isinstance(table_grp, self.GROUP_TYPE) and all(\\n isinstance(k, self.ARRAY_TYPE) for k in table_grp.values()\\n ):\\n table_name = table_grp.name\\n if table_name == \\\"/\\\":\\n for colname in self.grp.keys():\\n self.delcol(table_grp, colname)\\n else:\\n del self.grp[name]\",\n \"def cvv_ttype_drop(argv):\\n p = optparse.OptionParser()\\n p.add_option('-d', '--debug',\\n action='store_true', default=False, dest='debug',\\n help='run the debugger')\\n try:\\n (o, a) = p.parse_args(argv)\\n except SystemExit:\\n return\\n\\n if o.debug:\\n pdb.set_trace()\\n\\n result = dbschem.alter_table(table=\\\"checkables\\\", dropcol=\\\"ttypes\\\")\\n print(result)\",\n \"def test_drop_table(fs: FakeFilesystem) -> None:\\n fs.create_file(\\\"test.csv\\\", contents=CONTENTS)\\n\\n connection = connect(\\\":memory:\\\", [\\\"csvfile\\\"])\\n cursor = connection.cursor()\\n\\n sql = 'DROP TABLE \\\"test.csv\\\"'\\n cursor.execute(sql)\\n assert not Path(\\\"test.csv\\\").exists()\",\n \"def drop_tables() -> None:\\n print(\\\"Dropping database tables using SQLAlchemy ORM\\\")\\n Base.metadata.drop_all(engine)\\n print(\\\"Done dropping tables\\\")\",\n \"def _drop(self):\\n stmts = []\\n for ext in self:\\n if hasattr(self[ext], 'dropped'):\\n stmts.append(self[ext].drop())\\n return stmts\",\n \"def _drop_db(keep_tables=None):\\n server.db.session.remove()\\n if keep_tables is None:\\n keep_tables = []\\n meta = server.db.metadata\\n for table in reversed(meta.sorted_tables):\\n if table.name in keep_tables:\\n continue\\n server.db.session.execute(table.delete())\\n server.db.session.commit()\",\n \"def test_drop_table(self):\\n session = self.prepare(user_table=True)\\n\\n result = list(session.execute((\\\"SELECT * FROM system_schema.views \\\"\\n \\\"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\\\")))\\n assert len(result) == 1, \\\"Expecting {} materialized view, got {}\\\".format(1, len(result))\\n\\n assert_invalid(\\n session,\\n \\\"DROP TABLE ks.users;\\\",\\n \\\"Cannot drop table when materialized views still depend on it\\\"\\n )\\n\\n result = list(session.execute((\\\"SELECT * FROM system_schema.views \\\"\\n \\\"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\\\")))\\n assert len(result) == 1, \\\"Expecting {} materialized view, got {}\\\".format(1, len(result))\\n\\n session.execute(\\\"DROP MATERIALIZED VIEW ks.users_by_state;\\\")\\n session.execute(\\\"DROP TABLE ks.users;\\\")\\n\\n result = list(session.execute((\\\"SELECT * FROM system_schema.views \\\"\\n \\\"WHERE keyspace_name='ks' AND base_table_name='users' ALLOW FILTERING\\\")))\\n assert len(result) == 0, \\\"Expecting {} materialized view, got {}\\\".format(1, len(result))\",\n \"def test_drop_table(pawprint_default_tracker_db_with_table):\\n\\n tracker = pawprint_default_tracker_db_with_table\\n\\n # make sure table exists\\n with pytest.raises(ProgrammingError):\\n tracker.create_table()\\n\\n tracker.drop_table()\\n\\n with pytest.raises(ProgrammingError):\\n tracker.drop_table()\",\n \"def drop_db(self, dbname):\\n if dbname in self.list_dbs():\\n return self.delete(dbname).text\\n else:\\n raise NotExistingDatabase(dbname)\",\n \"def dropTable(self, schema, table, cascade=False):\\r\\n if cascade:\\r\\n return self.runSql('DROP TABLE IF EXISTS {} CASCADE'.format(self.encodeTableName(schema, table)))\\r\\n else:\\r\\n return self.runSql('DROP TABLE IF EXISTS {}'.format(self.encodeTableName(schema, table)))\",\n \"def drop_tables(self):\\n with sql.connect('./{}.db'.format(self.name)) as conn:\\n conn.execute(\\\"DROP TABLE tweets\\\")\\n conn.execute(\\\"DROP TABLE tweet_peaks\\\")\",\n \"def delete_table(self, table_name):\\n try:\\n conn = self.engine.connect()\\n conn.execute(\\\"DROP table \\\" + table_name)\\n print(\\\"-I- Deleted table \\\" + table_name)\\n except Exception as e:\\n print(\\\"-W- \\\" + str(e))\",\n \"def removedb(dbname):\\n os.system(\\\"dropdb %s\\\" % dbname)\",\n \"def Drop_Tables_From_DB(self, tables_list, d_params=None):\\n ctx = self.__Connect_To_Snowflake(d_params)\\n if len(tables_list) > 0:\\n for table in tables_list:\\n try:\\n ctx.cursor().execute(f\\\"drop table {table};\\\")\\n print(f\\\"Deleted : {table}\\\")\\n except:\\n print(f\\\"Doesn't exist : {table}\\\")\\n ctx.close()\\n return None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7439682","0.7192483","0.7143962","0.7049561","0.67682046","0.6763672","0.6577111","0.64398366","0.6311948","0.63029295","0.6295627","0.62305164","0.62251985","0.6221728","0.6211469","0.6206424","0.6188908","0.61786735","0.6153751","0.61287767","0.6127251","0.6079706","0.6077293","0.6073789","0.60670793","0.6065751","0.6057594","0.6040607","0.60100734","0.5984584","0.5980711","0.5963555","0.5953759","0.59504414","0.59462124","0.59436566","0.59106004","0.58927643","0.58776367","0.58455443","0.5832198","0.5828008","0.5821499","0.5816401","0.5799606","0.57777005","0.5776063","0.5776063","0.5776063","0.5776063","0.5776063","0.5776063","0.5776063","0.5776063","0.577541","0.5728962","0.57188725","0.5713513","0.5697315","0.56822616","0.5665707","0.56632304","0.56615096","0.5639035","0.56338507","0.55837446","0.5575427","0.5572302","0.55635196","0.5563503","0.5544732","0.55416566","0.5539528","0.5538348","0.55268455","0.55103785","0.55096877","0.5508594","0.55058146","0.54813933","0.54797035","0.5476098","0.54717827","0.5460716","0.545039","0.54393554","0.5423787","0.54217005","0.53989846","0.5396941","0.5380242","0.53756666","0.5361091","0.5359806","0.5350193","0.53495014","0.5347201","0.5345043","0.5332536","0.5325298"],"string":"[\n \"0.7439682\",\n \"0.7192483\",\n \"0.7143962\",\n \"0.7049561\",\n \"0.67682046\",\n \"0.6763672\",\n \"0.6577111\",\n \"0.64398366\",\n \"0.6311948\",\n \"0.63029295\",\n \"0.6295627\",\n \"0.62305164\",\n \"0.62251985\",\n \"0.6221728\",\n \"0.6211469\",\n \"0.6206424\",\n \"0.6188908\",\n \"0.61786735\",\n \"0.6153751\",\n \"0.61287767\",\n \"0.6127251\",\n \"0.6079706\",\n \"0.6077293\",\n \"0.6073789\",\n \"0.60670793\",\n \"0.6065751\",\n \"0.6057594\",\n \"0.6040607\",\n \"0.60100734\",\n \"0.5984584\",\n \"0.5980711\",\n \"0.5963555\",\n \"0.5953759\",\n \"0.59504414\",\n \"0.59462124\",\n \"0.59436566\",\n \"0.59106004\",\n \"0.58927643\",\n \"0.58776367\",\n \"0.58455443\",\n \"0.5832198\",\n \"0.5828008\",\n \"0.5821499\",\n \"0.5816401\",\n \"0.5799606\",\n \"0.57777005\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.5776063\",\n \"0.577541\",\n \"0.5728962\",\n \"0.57188725\",\n \"0.5713513\",\n \"0.5697315\",\n \"0.56822616\",\n \"0.5665707\",\n \"0.56632304\",\n \"0.56615096\",\n \"0.5639035\",\n \"0.56338507\",\n \"0.55837446\",\n \"0.5575427\",\n \"0.5572302\",\n \"0.55635196\",\n \"0.5563503\",\n \"0.5544732\",\n \"0.55416566\",\n \"0.5539528\",\n \"0.5538348\",\n \"0.55268455\",\n \"0.55103785\",\n \"0.55096877\",\n \"0.5508594\",\n \"0.55058146\",\n \"0.54813933\",\n \"0.54797035\",\n \"0.5476098\",\n \"0.54717827\",\n \"0.5460716\",\n \"0.545039\",\n \"0.54393554\",\n \"0.5423787\",\n \"0.54217005\",\n \"0.53989846\",\n \"0.5396941\",\n \"0.5380242\",\n \"0.53756666\",\n \"0.5361091\",\n \"0.5359806\",\n \"0.5350193\",\n \"0.53495014\",\n \"0.5347201\",\n \"0.5345043\",\n \"0.5332536\",\n \"0.5325298\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7213489"},"document_rank":{"kind":"string","value":"1"}}},{"rowIdx":20199,"cells":{"query":{"kind":"string","value":"Perform a bulk insert."},"document":{"kind":"string","value":"def insert_data_from_file(self, filename):\n self.get_cursor()\n if self.check_bulk_insert() and self.table.header_rows < 2 and (\n self.table.delimiter in [\"\\t\", \",\"]):\n print(\"Inserting data from \" + os.path.basename(filename) + \"...\")\n\n if self.table.delimiter == \"\\t\":\n fmt = \"TabDelimited\"\n elif self.table.delimiter == \",\":\n fmt = \"CSVDelimited\"\n\n if self.table.header_rows == 1:\n hdr = \"Yes\"\n else:\n hdr = \"No\"\n\n columns = self.table.get_insert_columns()\n\n need_to_delete = False\n add_to_record_id = 0\n\n if self.table.pk and not self.table.contains_pk:\n if '.' in os.path.basename(filename):\n proper_name = filename.split('.')\n len_name = len(proper_name)\n newfilename = '.'.join(\n proper_name[0:-1] if len_name > 0 else proper_name[0]\n ) + \"_new.\" + filename.split(\".\")[-1]\n else:\n newfilename = filename + \"_new\"\n\n if not os.path.isfile(newfilename):\n print(\"Adding index to \" + os.path.abspath(newfilename) + \"...\")\n read = open(filename, \"rb\")\n write = open(newfilename, \"wb\")\n to_write = \"\"\n\n for line in read:\n line = line.strip()\n to_write += str(id) + self.table.delimiter + line\n add_to_record_id += 1\n self.table.record_id += add_to_record_id\n\n write.write(to_write + os.linesep)\n write.close()\n read.close()\n need_to_delete = True\n columns = \"record_id, \" + columns\n else:\n newfilename = filename\n\n newfilename = os.path.abspath(newfilename)\n filename_length = (len(os.path.basename(newfilename)) * -1) - 1\n filepath = newfilename[:filename_length]\n statement = \"\"\"\nINSERT INTO \"\"\" + self.table_name() + \" (\" + columns + \"\"\")\nSELECT * FROM [\"\"\" + os.path.basename(newfilename) + ''']\nIN \"''' + filepath + '''\" \"Text;FMT=''' + fmt + ''';HDR=''' + hdr + ''';\"'''\n try:\n self.execute(statement)\n return True\n except BaseException:\n print(\"Couldn't bulk insert. Trying manual insert.\")\n self.connection.rollback()\n self.table.record_id -= add_to_record_id\n return None\n finally:\n if need_to_delete:\n os.remove(newfilename)\n\n return Engine.insert_data_from_file(self, filename)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _insert_bulk(self, iterable):\n self.cursor.executemany(self.INSERT, iterable)\n self.conn.commit()","def bulkInsert(self, url, values):\n pass","def insertmany(cls, *args):\n return InsertQuery(cls).bulk(True).set(*args)","def bulk_insert(objects, model, session):\n session.bulk_insert_mappings(model, objects)","def bulk_insert(self, data, insert_option):\n try:\n if (insert_option == 'distelec'):\n self.db[self.distelect_table_or_collection].insert_many(data)\n\n elif (insert_option == 'padron'):\n self.db[self.elector_table_or_collection].insert_many(data)\n\n elif (insert_option == 'province_stats'):\n self.db[self.province_stats_table_or_collection].insert_many(\n data)\n\n elif (insert_option == 'canton_stats'):\n self.db[self.canton_stats_table_or_collection].insert_many(\n data)\n\n elif (insert_option == 'district_stats'):\n self.db[self.district_stats_table_or_collection].insert_many(\n data)\n\n print(f\"--- The data was inserted ---\")\n\n except Exception as error:\n print(error)","def insert_data_bulk(self, table_name, data):\n if len(data) == 0:\n return\n\n fields = \", \".join(data[0].keys())\n value_placeholders = \", \".join([\"%s\" for f in data[0].keys()])\n query = \"INSERT INTO %s(%s) VALUES (%s)\" % (table_name, fields, value_placeholders)\n\n data = [tuple(self.pack(data_point.values())) for data_point in data]\n\n chunk_size = 50000\n data_chunks = [data[i:i + chunk_size] for i in range(0, len(data), chunk_size)]\n for chunk in data_chunks:\n self.cursor.executemany(query, chunk)\n self.db_connection.commit()","def bulk_insert(engine, model, entries):\n with session_scope(engine) as session:\n session.bulk_insert_mappings(model, entries)\n session.commit()","def insert(self, index, documents, batch_size=100):\n actions = []\n latest_index_id, begin_timestamp = self.__get_latest_index(index)\n\n for idx, doc in enumerate(documents):\n index_id = latest_index_id\n\n if doc[\"request_time\"] <= begin_timestamp:\n index_id = self.get_query_index(index, doc[\"request_time\"])\n\n action = {\n \"_index\": index + \"_\" + str(index_id),\n \"_type\": \"docs\",\n \"_source\": doc,\n }\n actions.append(action)\n\n if len(actions) == batch_size or idx == len(documents) - 1:\n print(\"Bulk ingesting started...\")\n\n try:\n bulk(self.client, actions, raise_on_error=True, request_timeout=200)\n except:\n print(\"Could not write the data.\")\n raise\n \n actions.clear()\n print(\"Bulk ingesting done\")\n if self.__get_index_size(index, latest_index_id) >= self.THRESHOLD:\n begin_timestamp = self.__update_index_timerange(\n index, latest_index_id\n )\n latest_index_id = self.__create_new_index(\n index, latest_index_id + 1, begin_timestamp\n )","def do_bulk(self, args):\n pass","def bulk_insert(cls, path=\"data.json\"):\n from json import load\n from codecs import open\n \n lists = load(open(path, \"r\", \"utf8\"))\n for lst in lists:\n ing = cls(content = lst)\n ing.put()","def insert_bulk(self, frame, table_name, conn=None, index=False, index_label=None, \n schema=None, chunksize=None, copy=True, auto_adjust=True):\n\n table = SQLTable(table_name, self, frame=frame, table_setup=False, index=index,\n if_exists='append', index_label=index_label, schema=schema)\n \n table.insert(conn=conn, bulk=True, chunksize=chunksize, copy=copy, \n auto_adjust=auto_adjust)","def insert(self, table_name, rows, bulk=True):\n table = self._create_table(table_name)\n return self._perform_query(table.insert(), rows, bulk)","async def bulk_insert(self, documents, alias=None):\n\n is_valid = True\n docs_to_insert = []\n\n for document_index, document in enumerate(documents):\n self.update_field_on_save_values(document, document._id is not None)\n try:\n is_valid = is_valid and self.validate_document(document)\n except Exception:\n err = sys.exc_info()[1]\n raise ValueError(\n \"Validation for document %d in the documents you are saving failed with: %s\"\n % (document_index, str(err))\n )\n\n if not is_valid:\n return\n\n docs_to_insert.append(document.to_son())\n\n if not is_valid:\n return\n\n doc_ids = await self.coll(alias).insert(docs_to_insert)\n\n for object_index, object_id in enumerate(doc_ids):\n documents[object_index]._id = object_id\n\n return documents","def test_orm_bulk_insert(n):\n session = Session(bind=engine)\n session.execute(\n insert(Customer),\n [\n {\n \"name\": \"customer name %d\" % i,\n \"description\": \"customer description %d\" % i,\n }\n for i in range(n)\n ],\n )\n session.commit()","async def insert_many(self, models):\n\n pass","def _batched_insert(\n self,\n objs,\n fields,\n batch_size,\n on_conflict=None,\n update_fields=None,\n unique_fields=None,\n ):\n connection = connections[self.db]\n ops = connection.ops\n max_batch_size = max(ops.bulk_batch_size(fields, objs), 1)\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\n inserted_rows = []\n bulk_return = connection.features.can_return_rows_from_bulk_insert\n for item in [objs[i : i + batch_size] for i in range(0, len(objs), batch_size)]:\n if bulk_return and (\n on_conflict is None or on_conflict == OnConflict.UPDATE\n ):\n inserted_rows.extend(\n self._insert(\n item,\n fields=fields,\n using=self.db,\n on_conflict=on_conflict,\n update_fields=update_fields,\n unique_fields=unique_fields,\n returning_fields=self.model._meta.db_returning_fields,\n )\n )\n else:\n self._insert(\n item,\n fields=fields,\n using=self.db,\n on_conflict=on_conflict,\n update_fields=update_fields,\n unique_fields=unique_fields,\n )\n return inserted_rows","def upload_entities(self, batch):\n # TODO Include a Do Not Overwrite call\n results = None\n atlas_endpoint = self.endpoint_url + \"/entity/bulk\"\n\n payload = AtlasClient._prepare_entity_upload(batch)\n\n postBulkEntities = requests.post(\n atlas_endpoint,\n json=payload,\n headers=self.authentication.get_authentication_headers()\n )\n\n results = self._handle_response(postBulkEntities)\n\n return results","def insert(self, conn, matches: List[Dict], verbose: bool) -> None:\n for i in range(0, len(matches), self.batch_size):\n batch = self._get_batch(i, matches)\n self._insert_json_to_sql(conn, batch, verbose)","def insert(self, *args):\n self.insert_count += 1\n self.total_ops += 1\n return super(BulkOperator, self).insert(*args)","def chunked_insert(model, items, chunk_size=150):\n # https://www.sqlite.org/limits.html#max_compound_select\n with db.atomic():\n for idx in range(0, len(items), chunk_size):\n model.insert_many(items[idx:idx+chunk_size]).execute()","def post_bulk(bulk_json):\n\n nbtry=0\n success=False\n\n # Bulk insert\n ####################################################################\n cnx.request(\"POST\",config.index+\"/\"+config.typ+\"/_bulk\",bulk_json) #\n ####################################################################\n\n # Get and read response from Elastic Search server\n resp=cnx.getresponse()\n resp_msg_json= resp.read()\n #sys.stderr.write( resp_msg_json + \"\\n\")\n resp_msg=json.loads(resp_msg_json)\n # Check status: both HTTP and within the Elastic Search answer\n if resp.status != httplib.OK or resp_msg[\"errors\"] is True:\n sys.stderr.write( bulk_json)\n sys.stderr.write( resp_msg_json +\"\\n\")\n raise Exception(\"ERROR when bulk loading into %s/%s: %d %s\\n\" % (config.index,config.typ, resp.status, resp.reason))","def batch_execute(self, conn):\n def batches(data, batch_size) -> list:\n \"\"\"Return batches of length `batch_size` from any object that\n supports iteration without knowing length.\"\"\"\n rv = []\n for idx, line in enumerate(data):\n if idx != 0 and idx % batch_size == 0:\n yield rv\n rv = []\n rv.append(line)\n yield rv\n\n columns = ColumnCollection(self.columns)\n if self.header:\n self.columns = [columns.get(h) for h in next(self.data)]\n columns = ColumnCollection(self.columns)\n\n total = 0\n query = BulkInsertQuery(self.table, columns)\n for batch in batches(self.data, self.batch_size):\n total += query.execute(conn, batch) or 0\n yield total","def bulk_copy_to_db(self):\n database = PostgreSQLCommon()\n\n try:\n file = open(self.file_name_hash)\n database.bulk_copy(file, self.storage_table)\n\n m.info('Bulk insert from %s has been successfully completed!'\n % self.file_name_hash)\n except Exception as err:\n m.error('OOps! Bulk insert operation FAILED! Reason: %s' % str(err))\n finally:\n database.close()\n\n if os.path.exists(self.file_name_hash):\n os.remove(self.file_name_hash)","def insert_many(collection, data):\n try:\n return collection.insert_many(data).inserted_ids\n except Exception as error:\n print(error)\n raise","def insert_data_many(settings_filename, query_filename, data_list):\n conn = connect_to_db(settings_filename)\n cursor = conn.cursor()\n \n query = load_query(query_filename)\n cursor.prepare(query)\n logging.debug(query)\n cursor.executemany(None, data_list)\n conn.commit()\n \n cursor.close()\n conn.close()\n\n return True","def bulk_insert(cls, device_id, imeis):\n insertion_object = []\n for imei in imeis:\n insertion_object.append({'imei': imei, 'normalized_imei': imei[0:14], 'device_id': device_id})\n res = db.engine.execute(ImeiDevice.__table__.insert(), insertion_object)\n res.close()","def thread_insert_data(collection_to_insert, collection_name):\n for item in collection_to_insert:\n insert_data_to_collection(item, collection_name)","def _bulk_add_rows(self, converted) :\n\n insert_sql = 'INSERT INTO \"%s\" VALUES (%s)' % (self.name, ','.join(['?'] * len(self.cols)))\n cur = self.con.cursor()\n cur.executemany(insert_sql, converted)","def _batch_insert(bq_client, table, rows):\n total_rows = len(rows)\n inserted_rows = 0\n batch = 1\n logger.info(\"Inserting %d rows into table %s\", total_rows,\n table.full_table_id)\n while inserted_rows < total_rows:\n start = (batch - 1) * MAX_BQ_INSERT_SIZE\n end = batch * MAX_BQ_INSERT_SIZE\n batch_rows = rows[start:end]\n inserted_rows += len(batch_rows)\n errors = _insert_rows(bq_client, table, batch_rows)\n if errors:\n print_bq_insert_errors(batch_rows, errors)\n logger.error(\n \"The program has been terminated due to BigQuery insertion \"\n \"errors.\")\n exit(1)\n else:\n logger.info(\"Batch %d: inserted rows %d to %d\", batch, start + 1,\n min(end, len(rows)))\n batch += 1\n logger.info(\"All rows inserted.\")","def bulk_insert(self, file):\n \n self.feed_type.ad_mapper.iter_from_file(file)\n\n max_pending = 10000 # Max INSERTs pending to commit\n current_pending = 0 # count the number of ads processing from the xml\n inserted_ads = 0\n\n info = {'status': None, 'file': file, 'inserted': None, 'e_msg': None}\n pending_raw_ads = []\n record_ids = []\n old_ads = 0\n repeated_ads = 0\n while True:\n try:\n raw_ad = RawAd()\n raw_ad.raw_content = self.feed_type.ad_mapper.get_raw_content()\n raw_ad.feed_in = self\n\n ######################## Begin - Filter section ################################\n # @TODO: Filters should be dinamic. E.g: implement some kind of observer pattern\n date_info = self.feed_type.ad_mapper.exec_method(\"FECHA\", raw_ad = raw_ad)\n days = (dtt.today() - dtt.strptime(date_info[\"date\"], date_info[\"_format\"])).days \n ######################## End - Filter section ################################\n\n\n if days > 30:\n old_ads += 1\n continue # It skips the remaining code in the loop. \n # This way we don't call to database in each iteration \n\n\n ######################## Begin - Filter section ################################\n # @TODO: Filters should be dinamic. E.g: implement some kind of observer pattern\n id = self.feed_type.ad_mapper.exec_method(\"ID\", raw_ad = raw_ad)[\"_id_in_feed\"]\n record_id = id + \",\" + self.feed_type.ad_mapper.exec_method(\"URL\", raw_ad = raw_ad)[\"link\"]\n ad_exists = DBSession.execute(\"SELECT 1 FROM fp_feeds_in_records WHERE id = :id\", {\"id\": record_id}).first()\n ######################## End - Filter section ################################\n if ad_exists:\n repeated_ads += 1\n else:\n pending_raw_ads.append(\n {\n \"raw_ad\": raw_ad.raw_content,\n \"feed_in_id\": self.id\n })\n\n record_ids.append({\"id\": record_id})\n\n current_pending += 1\n \n if( current_pending == max_pending):\n self.__insert(pending_raw_ads, record_ids)\n\n inserted_ads += current_pending\n current_pending = 0\n\n except StopIteration:\n if(current_pending != 0):\n self.__insert(pending_raw_ads, record_ids)\n \n inserted_ads += current_pending\n current_pending = 0\n\n # It updates the processed date's feed\n self.last_processed_date = date.today()\n DBSession.commit()\n \n info['status'] = 'ok'\n info['inserted'] = inserted_ads\n info['repeated_ads'] = repeated_ads\n info['old_ads'] = old_ads\n\n return info\n\n except Exception as e:\n info['status'] = type(e).__name__\n info['inserted'] = inserted_ads\n info['e_msg'] = str(e)\n info['repeated_ads'] = repeated_ads\n info['old_ads'] = old_ads\n\n return info","def insert_multiple_db_entries(self, _collection=None, _db_entries=None):\n assert _collection is not None, 'Must specify collection'\n assert _db_entries is not None, 'Must specify documents'\n try:\n # ordered=False ensures that every insert operation will be attempted\n # so that if, e.g., a document already exists, it will be simply skipped\n self.db['db'][_collection].insert_many(_db_entries, ordered=False)\n except pymongo.errors.BulkWriteError as bwe:\n print(*time_stamps(), bwe.details)\n except Exception as _e:\n traceback.print_exc()\n print(_e)","def insert_json(table=None,\n bulk_size=1000,\n concurrency=25,\n hosts=None,\n infile=None,\n output_fmt=None):\n if not hosts:\n return print_only(infile, table)\n\n queries = (to_insert(table, d) for d in dicts_from_lines(infile))\n bulk_queries = as_bulk_queries(queries, bulk_size)\n print('Executing inserts: bulk_size={} concurrency={}'.format(\n bulk_size, concurrency), file=sys.stderr)\n\n stats = Stats()\n with clients.client(hosts, concurrency=concurrency) as client:\n f = partial(aio.measure, stats, client.execute_many)\n try:\n aio.run_many(f, bulk_queries, concurrency)\n except clients.SqlException as e:\n raise SystemExit(str(e))\n try:\n print(format_stats(stats.get(), output_fmt))\n except KeyError:\n if not stats.sampler.values:\n raise SystemExit('No data received via stdin')\n raise","def test_select_bulk_insert_transfer(self, *args):\n task = VerticaToMySqlTransfer(task_id='test_task_id',\n sql='select a, b, c',\n mysql_table='test_table',\n vertica_conn_id='test_vertica_conn_id',\n mysql_conn_id='test_mysql_conn_id',\n params={},\n bulk_load=True,\n dag=self.dag)\n task.execute(None)","def ingest(self, items: list):\n if not items:\n logging.info(f\"{self.__class__.__name__} : no `items` to store into database.\")\n return\n\n threads = list()\n\n for index, item in enumerate(items):\n logging.info(f\"{self.__class__.__name__} : create and start thread {index}.\")\n x = threading.Thread(target=self.validate_and_insert, args=(index,))\n threads.append(x)\n x.start()\n\n for index, thread in enumerate(threads):\n logging.info(f\"{self.__class__.__name__} : before joining thread {index}.\")\n thread.join()\n logging.info(f\"{self.__class__.__name__} : thread {index} done\")","def report_bulk(results):\n from pprint import pprint\n pprint(results)\n if results.get('writeConcernErrors', []) or results.get('writeErrors', []):\n raise BulkFailure(\"Failed on bulk insertion\")","def _load_elastic(self, sqldata):\n inserts = []\n for r in sqldata:\n body = self._preprocess(dict(r.items()))\n if not body:\n continue # Skip if preprocessing returns False\n index_name = self._get_index_name(body['TIME_STAMP'])\n document = {\n \"_index\" : index_name,\n \"_type\" : 'default', # Hardcoded - we only have 1 doctype\n \"_id\" : body[self.seq_field],\n \"_source\" : body\n }\n inserts.append(document)\n\n # update sequence to last item in the results\n self.seq = sqldata[-1][self.seq_field]\n \n # Insert list of documents into elasticsearch\n status = helpers.bulk(self.es, inserts, self.chunk_size)\n self.logger.info(\"Inserted %d chunks into %s\" % (self.chunk_size,\n index_name))\n return status","def test_insert_batch(self, queue_mock):\n from sosbeacon.utils import insert_tasks\n\n tasks = []\n for i in xrange(1, 10):\n tasks.append(object())\n added = insert_tasks(tasks, 'default')\n self.assertEqual(added, 9)","def insert(cls, values):\n result = yield InsertQuery(cls, values).execute()\n returnValue(result)","def load_data(connection, insert_sql, data):\n cur = connection.cursor()\n for d in data:\n cur.execute(insert_sql, d)\n connection.commit()","def test_issue_288(self):\n conn = self.connect()\n cursor = conn.cursor()\n data = [(0, \"bob\", 21, 123), (1, \"jim\", 56, 45), (2, \"fred\", 100, 180)]\n cursor.executemany(\n \"\"\"insert\ninto bulkinsert (id, name,\nage, height)\nvalues (%s,\n%s , %s,\n%s ) on duplicate key update\nage = values(age)\n \"\"\",\n data,\n )\n self.assertEqual(\n cursor._executed.strip(),\n bytearray(\n b\"\"\"insert\ninto bulkinsert (id, name,\nage, height)\nvalues (0,\n'bob' , 21,\n123 ),(1,\n'jim' , 56,\n45 ),(2,\n'fred' , 100,\n180 ) on duplicate key update\nage = values(age)\"\"\"\n ),\n )\n cursor.execute(\"commit\")\n self._verify_records(data)","def load_variant_bulk(self, variants):\n if len(variants) == 0:\n return\n\n LOG.debug(\"Loading variant bulk\")\n try:\n result = self.variant_collection.insert_many(variants)\n except (DuplicateKeyError, BulkWriteError) as err:\n # If the bulk write is wrong there are probably some variants already existing\n # In the database. So insert each variant\n LOG.warning(\"Bulk insertion failed - attempting separate variant upsert for this bulk\")\n for var_obj in variants:\n try:\n self.upsert_variant(var_obj)\n except IntegrityError as err:\n pass\n\n return","def insert_records(self, insert_query, insert_query_columns, wiki_data, table_name):\n print(\"Inserting {} rows into {}\".format(len(wiki_data), table_name))\n for index, item in enumerate(wiki_data):\n values_to_insert = [item[column]['value'] for column in insert_query_columns]\n try:\n self.cur.execute(insert_query, values_to_insert)\n except ValueError as ve:\n print(\"Could not execute query : {} with values\".format(insert_query, values_to_insert))\n raise ve\n\n if index % 1000 == 0:\n print(\"Inserted {} rows\".format(index))\n print(\"Inserted {} rows\".format(len(wiki_data)))\n print(\"Finished inserting {}\".format(table_name))","def insert_many_execute(self) -> None:\n self.connection.isolation_level = None\n self.cursor.execute('BEGIN TRANSACTION')\n for i in self.__sql_buffer.split(';'):\n self.cursor.execute(i)\n self.__sql_buffer = \"\"\n self.cursor.execute('COMMIT')","def insert(db_name, collection_name, docs):\n db = client[db_name]\n collection = db[collection_name]\n return collection.insert_many(docs)","def insert_data(stored_data, table_name):\r\n for item in stored_data:\r\n cursor.execute('''INSERT INTO {} VALUES(?, ?, ?, ?)'''.format(table_name), item)","def insert_many(self, frame, table_name, conn=None, index=False, index_label=None, \n schema=None, chunksize=None, copy=True, auto_adjust=True):\n \n table = SQLTable(table_name, self, frame=frame, table_setup=False, index=index,\n if_exists='append', index_label=index_label, schema=schema)\n \n table.insert(conn=conn, bulk=False, chunksize=chunksize, copy=copy, \n auto_adjust=auto_adjust)","def store_index(self, index, doc_type, source_list, init_id):\n\n bulk_actions = []\n doc_id = init_id\n\n for source in source_list:\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\"_source\"])\n bulk_actions.append(data_body)\n doc_id += 1\n\n print 'inserting - ', len(bulk_actions)\n helpers.bulk(self.es, bulk_actions)","def bq_insert_rows(bq_client, table, rows):\n _batch_insert(bq_client, table, rows)","def insert(self, json_data, batch=None):\n headers = {'Content-type': 'application/json;charset=UTF-8'}\n url = '/'.join([self.url, self.db])\n time.sleep(0.01)\n if batch:\n r = requests.post(url, data=json_data, headers=headers, params={'batch': 'ok'})\n else:\n r = requests.post(url, data=json_data, headers=headers) \n time.sleep(0.01)\n if not r.status_code in (201, 202):\n raise Exception(\"HTTP \" + str(r.status_code))","def insert_data(settings_filename, query_filename, row_list):\n conn = connect_to_db(settings_filename)\n cursor = conn.cursor()\n\n query = load_query(query_filename)\n cursor.execute(query,row_list)\n conn.commit()\n \n cursor.close()\n conn.close()\n\n return True","def insert_boost(connection: DBConnection, documents: Sequence[Document]) -> None:\n max_ = len(documents)\n current = 0\n print() # print an extra line, because we will delete lines with printing \\r\n for chunk in chunks(documents):\n\n connection.execute(\"BEGIN TRANSACTION\")\n for doc in chunk:\n connection.execute(\n \"INSERT INTO boost(did, date, page) VALUES (?, ?, ?)\", (doc.id, doc.date, doc.page))\n connection.execute(\"COMMIT\")\n current += len(chunk)\n print(f\"\\r[{current}/{max_}] boost done\", end='')\n print()","def db_insertmany(table: str, columns: list, values: list):\n\n db, c = start_db()\n\n cols = ', '.join(columns)\n vals = ', '.join(['?' for _ in values[0]])\n query = f'INSERT INTO {table} ({cols}) VALUES ({vals})'\n\n c.executemany(query, values)\n db.commit()\n db.close()","def insert_tfs(connection: DBConnection, documents: Sequence[Document]) -> None:\n max_ = len(documents)\n current = 0\n print() # print an extra line, because we will delete lines with printing \\r\n for chunk in chunks(documents):\n rows = (d.get_tfs_rows() for d in chunk)\n connection.execute(\"BEGIN TRANSACTION\")\n for row in rows:\n connection.executemany(\n \"INSERT INTO tfs(did, term, tf) VALUES (?, ?, ?)\", row)\n connection.execute(\"COMMIT\")\n current += len(chunk)\n print(f\"\\r[{current}/{max_}] doc-tfs done\", end='')\n print()","def insert_documents(connection: DBConnection, documents: Sequence[Document]) -> None:\n max_ = len(documents)\n current = 0\n print() # print an extra line, because we will delete lines with printing \\r\n for chunk in chunks(documents):\n connection.execute(\"BEGIN TRANSACTION\")\n for doc in chunk:\n # python doesn't support prepared statements, but instead has a builtin sql cache\n connection.execute(\n \"INSERT INTO docs(did, title, url) VALUES (?, ?, ?)\", doc.convert_to_tuple())\n current += 1\n print(f\"\\r[{current}/{max_}] doc done\", end='')\n connection.execute(\"COMMIT\")","def insertmany(self, table, values):\n col_name = self.table_cols[table][1:]\n sql = 'INSERT INTO %s(%s) VALUES (%s)' % (table, ','.join(col_name), ','.join(['%s'] * len(values[0])))\n Log.debug('DB -> %s' % sql)\n self.execute(sql, values)","def execute_many(self, query: str, args):\n return self.insert_many(query, args)","def insert_data(self, table_name, data):\n for data_point in data:\n query = \"INSERT INTO %s(%s) VALUES (%s)\"\n\n fields = \", \".join(data_point.keys())\n values = \", \".join([self.pack_data(value) for value in data_point.values()])\n self.cursor.execute(query % (table_name, fields, values))\n self.db_connection.commit()","def write(self, batch):\n cursor = connection.cursor()\n while batch:\n values = [\n \"(%s, %s)\" % (\n psycopg2.Binary(k),\n psycopg2.Binary(v)\n ) for k, v in batch[:self.BATCH_SIZE]]\n sql = \"INSERT INTO %s(k,v) VALUES %s\" % (self.table, \",\".join(values))\n batch = batch[self.BATCH_SIZE:]\n cursor.execute(sql)\n cursor.execute(\"COMMIT\")","def upload(\n workspace: str, table: str, key: str = \"_key\", overwrite: bool = False\n) -> Any:\n space = db.get_workspace_db(workspace, readonly=False)\n if space.has_collection(table):\n raise AlreadyExists(\"table\", table)\n\n app.logger.info(\"Bulk Loading\")\n\n # Read the request body into CSV format\n body = decode_data(request.data)\n\n try:\n # Type to a Dict rather than an OrderedDict\n rows: List[Dict[str, str]] = list(csv.DictReader(StringIO(body)))\n except csv.Error:\n raise CSVReadError()\n\n # Perform validation.\n validate_csv(rows, key, overwrite)\n\n # Once we reach here, we know that the specified key field must be present,\n # and either:\n # key == \"_key\" # noqa: E800\n # or key != \"_key\" and the \"_key\" field is not present\n # or key != \"_key\" and \"_key\" is present, but overwrite = True\n if key != \"_key\":\n rows = set_table_key(rows, key)\n\n # Set the collection, paying attention to whether the data contains\n # _from/_to fields.\n fieldnames = rows[0].keys()\n edges = \"_from\" in fieldnames and \"_to\" in fieldnames\n coll = space.create_collection(table, edge=edges)\n\n # Insert the data into the collection.\n results = coll.insert_many(rows)\n return {\"count\": len(results)}","def test_bulk_insert(self):\n\n class Comment(EmbeddedDocument):\n name = StringField()\n\n class Post(EmbeddedDocument):\n comments = ListField(EmbeddedDocumentField(Comment))\n\n class Blog(Document):\n title = StringField(unique=True)\n tags = ListField(StringField())\n posts = ListField(EmbeddedDocumentField(Post))\n\n Blog.drop_collection()\n\n # Recreates the collection\n assert 0 == Blog.objects.count()\n\n comment1 = Comment(name=\"testa\")\n comment2 = Comment(name=\"testb\")\n post1 = Post(comments=[comment1, comment2])\n post2 = Post(comments=[comment2, comment2])\n\n # Check bulk insert using load_bulk=False\n blogs = [Blog(title=\"%s\" % i, posts=[post1, post2]) for i in range(99)]\n with query_counter() as q:\n assert q == 0\n Blog.objects.insert(blogs, load_bulk=False)\n assert q == 1 # 1 entry containing the list of inserts\n\n assert Blog.objects.count() == len(blogs)\n\n Blog.drop_collection()\n Blog.ensure_indexes()\n\n # Check bulk insert using load_bulk=True\n blogs = [Blog(title=\"%s\" % i, posts=[post1, post2]) for i in range(99)]\n with query_counter() as q:\n assert q == 0\n Blog.objects.insert(blogs)\n assert q == 2 # 1 for insert 1 for fetch\n\n Blog.drop_collection()\n\n comment1 = Comment(name=\"testa\")\n comment2 = Comment(name=\"testb\")\n post1 = Post(comments=[comment1, comment2])\n post2 = Post(comments=[comment2, comment2])\n blog1 = Blog(title=\"code\", posts=[post1, post2])\n blog2 = Blog(title=\"mongodb\", posts=[post2, post1])\n blog1, blog2 = Blog.objects.insert([blog1, blog2])\n assert blog1.title == \"code\"\n assert blog2.title == \"mongodb\"\n\n assert Blog.objects.count() == 2\n\n # test inserting an existing document (shouldn't be allowed)\n with pytest.raises(OperationError) as exc_info:\n blog = Blog.objects.first()\n Blog.objects.insert(blog)\n assert (\n str(exc_info.value)\n == \"Some documents have ObjectIds, use doc.update() instead\"\n )\n\n # test inserting a query set\n with pytest.raises(OperationError) as exc_info:\n blogs_qs = Blog.objects\n Blog.objects.insert(blogs_qs)\n assert (\n str(exc_info.value)\n == \"Some documents have ObjectIds, use doc.update() instead\"\n )\n\n # insert 1 new doc\n new_post = Blog(title=\"code123\", id=ObjectId())\n Blog.objects.insert(new_post)\n\n Blog.drop_collection()\n\n blog1 = Blog(title=\"code\", posts=[post1, post2])\n blog1 = Blog.objects.insert(blog1)\n assert blog1.title == \"code\"\n assert Blog.objects.count() == 1\n\n Blog.drop_collection()\n blog1 = Blog(title=\"code\", posts=[post1, post2])\n obj_id = Blog.objects.insert(blog1, load_bulk=False)\n assert isinstance(obj_id, ObjectId)\n\n Blog.drop_collection()\n post3 = Post(comments=[comment1, comment1])\n blog1 = Blog(title=\"foo\", posts=[post1, post2])\n blog2 = Blog(title=\"bar\", posts=[post2, post3])\n Blog.objects.insert([blog1, blog2])\n\n with pytest.raises(NotUniqueError):\n Blog.objects.insert(Blog(title=blog2.title))\n\n assert Blog.objects.count() == 2","def insert_many(self, conn, key, **kwargs):\n conn.zadd(key, **kwargs)","def insert_data(self) -> None:\n if self.min_insert_size > self.insert_count:\n LOG.debug(\"Not enough data for insert....\")\n return\n LOG.debug(f'Inserting {self.insert_count} records...')\n self.insert.write(self.copy_trailer)\n self.insert.seek(0)\n conn = pg.connect(self.dsn)\n with conn.cursor() as cur:\n cur.copy_expert(self.cmd, self.insert)\n conn.commit()\n conn.close()\n self.insert.close()\n self.create_byte_buffer()","def batch_insert_direct(self, data, *args, **kwargs):\n return pycassa.ColumnFamily.batch_insert(self, data, *args, **kwargs)","def bulkupload_entitie_records(self, entity_upload_parameters, tmp_file, progress=None):\n records = self.service_client.factory.create(\"ns2:ArrayOfstring\")\n tmp_csv_file = io.open(tmp_file, encoding='utf-8-sig')\n\n records.string = [x.strip() for x in tmp_csv_file.readlines()]\n \n try:\n #print(self.service_client)\n response = self.service_client.UploadEntityRecords(\n AccountId=self._authorization_data.account_id,\n EntityRecords=records,\n ResponseMode=entity_upload_parameters.response_mode\n )\n if self.need_to_fall_back_to_async(response):\n headers = self.service_client.get_response_header()\n operation = BulkUploadOperation(\n request_id=response.RequestId,\n authorization_data=self._authorization_data,\n poll_interval_in_milliseconds=self._poll_interval_in_milliseconds,\n environment=self._environment,\n tracking_id=headers['TrackingId'] if 'TrackingId' in headers else None,\n **self.suds_options\n )\n file_path = self.download_upload_result(operation, entity_upload_parameters, progress)\n return self.read_result_from_bulk_file(file_path)\n else:\n return self.read_bulkupsert_response(response) \n except Exception as ex:\n if 'OperationNotSupported' == operation_errorcode_of_exception(ex):\n return self.bulkupload_entities(entity_upload_parameters, tmp_file, progress)\n else:\n raise ex","def upload_entities(self, entity_upload_parameters, progress=None):\n \n tmp_file = path.join(self.working_directory, '{0}.csv'.format(uuid.uuid1()))\n with BulkFileWriter(tmp_file) as writer:\n for entity in entity_upload_parameters.entities:\n writer.write_entity(entity)\n\n if (self.need_to_try_upload_entity_records_sync_first(entity_upload_parameters)):\n return self.bulkupload_entitie_records(entity_upload_parameters, tmp_file, progress)\n else:\n return self.bulkupload_entities(entity_upload_parameters, tmp_file, progress)","def insert_many(self, data: list[dict], db_name: str = None, collection_name: str = None, **kwargs) -> bool:\n db: Database = self.db if db_name is None else self.client[db_name]\n coll: Collection = self.coll if collection_name is None else db[collection_name]\n \n coll.insert_many(data)\n\n return True","def insert(self, items=''):\n cur = self.conn.cursor()\n\n format_args = {'table': self.__name__,\n 'items': ', '.join(items.keys()),\n 'values': ', '.join([':'+key for key in items.keys()])}\n \n insert_query = \"\"\"\n INSERT INTO {table} ({items}) VALUES ({values})\n \"\"\".format(**format_args)\n\n cur.execute(insert_query, items)","async def test_valid_insert_batch(database,valid_data):\n await database.setup_database(reset=True)\n data = []\n for _id,user_id,embeddings,batch_id in valid_data: #pylint: disable=unused-variable\n await database.insert_user(user_id)\n data.append((_id,user_id,embeddings,1))\n await database.insert_batch(data)\n await database.close_pool()","def elastic_data_sync(from_ts, to_ts, conn_obj, idx, type):\n if from_ts:\n query = {\"_id\": {\"$gt\": from_ts, \"$lte\": to_ts}}\n else:\n query = {\"_id\": {\"$lte\": to_ts}}\n pkg_meta = conn_obj.find(query)\n #Call elasticsearch bulk insert with mongo cursor\n data = {\"data_iter\": pkg_meta, \"index\": idx, \"_type\": type,\n \"mapping\": ELASTIC_MAPPINGS.get(idx, {})}\n es_sync = ElasticSearch()\n status, res = es_sync.bulk(**data)\n return status, res","def multiple_insert(self, tablename, values, seqname=None, _test=False): \n if not values:\n return []\n \n if not self.supports_multiple_insert:\n out = [self.insert(tablename, seqname=seqname, _test=_test, **v) for v in values]\n if seqname is False:\n return None\n else:\n return out\n \n keys = values[0].keys()\n #@@ make sure all keys are valid\n\n for v in values:\n if v.keys() != keys:\n raise ValueError, 'Not all rows have the same keys'\n\n sql_query = SQLQuery('INSERT INTO %s (%s) VALUES ' % (tablename, ', '.join(keys)))\n\n for i, row in enumerate(values):\n if i != 0:\n sql_query.append(\", \")\n SQLQuery.join([SQLParam(row[k]) for k in keys], sep=\", \", target=sql_query, prefix=\"(\", suffix=\")\")\n \n if _test: return sql_query\n\n db_cursor = self._db_cursor()\n if seqname is not False: \n sql_query = self._process_insert_query(sql_query, tablename, seqname)\n\n if isinstance(sql_query, tuple):\n # for some databases, a separate query has to be made to find \n # the id of the inserted row.\n q1, q2 = sql_query\n self._db_execute(db_cursor, q1)\n self._db_execute(db_cursor, q2)\n else:\n self._db_execute(db_cursor, sql_query)\n\n try: \n out = db_cursor.fetchone()[0]\n out = range(out-len(values)+1, out+1) \n except Exception: \n out = None\n\n if not self.ctx.transactions: \n self.ctx.commit()\n return out","def insertall(self, rows):\n method = 'tabledata().insertAll().execute()'\n body = {}\n body['rows'] = [{'json': row} for row in rows]\n body[\"kind\"] = \"bigquery#tableDataInsertAllRequest\"\n return self._make_request(method, body)","def linear(files):\n return list(map(insert_to_mongo, files))","def insert_(statement: str, db_conf) -> []:\n try:\n result = db_conf.execute(statement)\n if result:\n return result\n except psycopg2.IntegrityError:\n pass\n return []","def bulk_index(data):\n\n def bulk_api_string(item):\n return f\"{{\\\"index\\\":{{}}\\n{json.dumps(item)}\"\n\n body = '\\n'.join([bulk_api_string(item) for item in data]) + '\\n'\n\n return make_request(\n requests.post,\n url=f\"{connection.hostname}:{connection.port}/{connection.index}/_bulk\",\n headers={'Content-Type': 'application/json'},\n auth=auth,\n data=body\n )","def load_fixtures(self, dbname, table, data):\n db = self.databases[dbname]['db']\n db.execute('BEGIN')\n for row in data:\n columns = row.keys()\n q = db.Insert(table, cols=columns)\n db.execute(q, row)\n db.execute('COMMIT')","def bulk_insert_into_table(cursor, operation, cnx, \n mute=True, autocommit=True): \n op_list=re.split(';\\s*',operation)\n count=0\n for op in op_list:\n if mute:\n try:\n cursor.execute(op)\n if autocommit:\n if not cnx.autocommit:\n cnx.commit()\n result = cursor\n count += result.rowcount\n print(\"Warnings: \" + str(result.fetchwarnings()) + \".\")\n except mysql.connector.Error as err:\n print(err.msg + \".\")\n else:\n try:\n cursor.execute(op)\n if autocommit:\n if not cnx.autocommit:\n cnx.commit()\n result = cursor\n print(f\"Number of rows affected by statement \"\n f\"'{result.statement}': {result.rowcount}.\")\n print(\"Warnings: \" + str(result.fetchwarnings()) + \".\")\n except mysql.connector.Error as err:\n print(err.msg + \".\")\n if mute:\n print(f\"Number of rows affected by statement: {count}.\")\n print(\"Done Inserting.\")","def bulk(self) -> None:\n helpers.bulk(self.client, self.gen_business_data(BUSINESS_FP))\n helpers.bulk(self.client, self.gen_review_data(REVIEW_FP))\n helpers.bulk(self.client, self.gen_tip_data(TIP_FP))","def test_bulk_observable_add(self):\n observables = [\"{}{}.com\".format(_random_domain(), i) for i in range(20)]\n info = self.api.observable_bulk_add(observables, ['bulk'])\n self.assertEqual(len(info), 20)","def _insert(\n self,\n objs,\n fields,\n returning_fields=None,\n raw=False,\n using=None,\n on_conflict=None,\n update_fields=None,\n unique_fields=None,\n ):\n self._for_write = True\n if using is None:\n using = self.db\n query = sql.InsertQuery(\n self.model,\n on_conflict=on_conflict,\n update_fields=update_fields,\n unique_fields=unique_fields,\n )\n query.insert_values(fields, objs, raw=raw)\n return query.get_compiler(using=using).execute_sql(returning_fields)","async def insert(self, args: Dict[str, Any]):\n keys = \", \".join(args.keys())\n values = \", \".join([f\"${i + 1}\" for i in range(len(args))])\n\n conn: Connection\n async with self.db_pool.acquire() as conn:\n await conn.execute(\n f\"INSERT INTO {self.table_name} \"\n f\"({keys}) VALUES ({values})\",\n *args.values(),\n )","def bulkCreateTasks(request, *args, **kwargs):\n import settings\n\n # keep track of our own timelimit (20 seconds)\n timelimit = 20000\n timekeeper = Timekeeper(timelimit)\n\n post_dict = request.POST\n\n bulk_create_key = post_dict.get('bulk_create_key')\n if not bulk_create_key:\n return error_handler.logErrorAndReturnOK(\n 'Not all POST data specified in: %s' % post_dict)\n\n bulk_data = bulk_create_model.GCIBulkCreateData.get(bulk_create_key)\n if not bulk_data:\n return error_handler.logErrorAndReturnOK(\n 'No valid data found for key: %s' % bulk_create_key)\n\n # note that we only query for the quota once\n org_admin = bulk_data.created_by\n task_quota = org_logic.getRemainingTaskQuota(org_admin.scope)\n\n tasks = bulk_data.tasks\n while len(tasks) > 0:\n try:\n # check if we have time\n timekeeper.ping()\n\n if settings.GCI_TASK_QUOTA_LIMIT_ENABLED and task_quota <= 0:\n return error_handler.logErrorAndReturnOK(\n 'Task quota reached for %s' %(org_admin.scope.name))\n\n # remove the first task\n task_as_string = tasks.pop(0)\n\n loaded_task = simplejson.loads(task_as_string)\n task = {}\n for key, value in loaded_task.iteritems():\n # If we don't do this python will complain about kwargs not being\n # strings when we try to save the new task.\n task[key.encode('UTF-8')] = value\n\n logging.info('Uncleaned task: %s' %task)\n # clean the data\n errors = _cleanTask(task, org_admin)\n\n if errors:\n logging.warning(\n 'Invalid task data uploaded, the following errors occurred: %s'\n %errors)\n bulk_data.errors.append(db.Text(\n 'The task in row %i contains the following errors.\\n %s' \\\n %(bulk_data.tasksRemoved(), '\\n'.join(errors))))\n\n # at-most-once semantics for creating tasks\n bulk_data.put()\n\n if errors:\n # do the next task\n continue\n\n # set other properties\n task['link_id'] = 't%i' % (int(time.time()*100))\n task['scope'] = org_admin.scope\n task['scope_path'] = org_admin.scope_path\n task['program'] = org_admin.program\n task['status'] = 'Unpublished'\n task['created_by'] = org_admin\n task['modified_by'] = org_admin\n\n # create the new task\n logging.info('Creating new task with fields: %s' %task)\n task_logic.updateOrCreateFromFields(task)\n task_quota = task_quota - 1\n except DeadlineExceededError:\n # time to bail out\n pass\n\n if len(tasks) == 0:\n # send out a message\n notifications.sendBulkCreationCompleted(bulk_data)\n bulk_data.delete()\n else:\n # there is still work to be done, do a non 500 response and requeue\n task_params = {\n 'bulk_create_key': bulk_data.key().id_or_name()\n }\n new_task = taskqueue.Task(params=task_params,\n url=BULK_CREATE_URL)\n # add to the gci queue\n new_task.add(queue_name='gci-update')\n\n # we're done here\n return http.HttpResponse('OK')","def insert_mass(self, table_name, data, ignore=False):\n fields = []\n to_insert = []\n for row in data:\n if not len(fields):\n fields = map((lambda s: \"`\" + str(s) + \"`\"), row.keys())\n values = map(self.quote, row.values())\n to_insert.append(\"({0})\".format(\", \".join(values)))\n\n if len(to_insert)%50 == 0:\n self.q(\n \"INSERT \" + (\"IGNORE\" if ignore else \"\") + \" INTO `{0}` ({1}) VALUES {2}\"\n .format(table_name, \", \".join(fields), \", \".join(to_insert))\n )\n to_insert = []\n\n if len(to_insert):\n self.q(\n \"INSERT \" + (\"IGNORE\" if ignore else \"\") + \" INTO `{0}` ({1}) VALUES {2}\"\n .format(table_name, \", \".join(fields), \", \".join(to_insert))\n )","def run_insert_example():\n table = \"actors\"\n insert_values = {\n 'id': 3,\n 'name': \"Matt\",\n 'last_name': \"Smith\",\n 'country': \"England\"}\n print querify.insert_from_dict(table, insert_values)\n\n insert_col_list = [\"id\", \"name\", \"last_name\", \"country\"]\n insert_val_list = [\n [1, \"Chris\", \"Eccleston\", \"England\"],\n [2, \"David\", \"Tennant\", \"Scotland\"],\n [3, \"Matt\", \"Smith\", \"England\"]]\n print querify.insert_from_list(table, insert_col_list, insert_val_list)","def put(self,items,priority=0):\n with self.pdq:\n self.pdq.cursor().executemany('insert into pdq values (?,?)',[(item,priority) for item in self._toiter(items)])","def insert_many(self, query: str, args):\n cursor = self._cursor()\n try:\n cursor.execute_many(query, args)\n return cursor.lastrowid\n finally:\n cursor.close()","def test_bulk(self):\n\n class BlogPost(Document):\n title = StringField()\n\n BlogPost.drop_collection()\n\n post_1 = BlogPost(title=\"Post #1\")\n post_2 = BlogPost(title=\"Post #2\")\n post_3 = BlogPost(title=\"Post #3\")\n post_4 = BlogPost(title=\"Post #4\")\n post_5 = BlogPost(title=\"Post #5\")\n\n post_1.save()\n post_2.save()\n post_3.save()\n post_4.save()\n post_5.save()\n\n ids = [post_1.id, post_2.id, post_5.id]\n objects = BlogPost.objects.in_bulk(ids)\n\n assert len(objects) == 3\n\n assert post_1.id in objects\n assert post_2.id in objects\n assert post_5.id in objects\n\n assert objects[post_1.id].title == post_1.title\n assert objects[post_2.id].title == post_2.title\n assert objects[post_5.id].title == post_5.title\n\n objects = BlogPost.objects.as_pymongo().in_bulk(ids)\n assert len(objects) == 3\n assert isinstance(objects[post_1.id], dict)\n\n BlogPost.drop_collection()","def bulk_index_records(records):\n indexer = RecordIndexer()\n\n click.echo('Bulk indexing {} records...'.format(len(records)))\n indexer.bulk_index([str(r.id) for r in records])\n indexer.process_bulk_queue()\n click.echo('Indexing completed!')","def insert_to_elastic(elastic, paper_authors, papers, authors, index_name):\n helpers.bulk(elastic, merge_to_elastic(paper_authors, papers, authors, index_name))","def executeQuery(self, segments=None,):\n if not segments: segments = self.segments\n query =''.join(['INSERT INTO ', self.tableName, ' (',\n ', '.join(self.firstLine), ') VALUES ',\n ', '.join([segment for segment in segments]), ';'])\n try:\n self.cursorExecute(query)\n except:\n print 'Bulk query rejected, splitting into smaller queries.'\n self.handleSQLRejection(0, len(self.segments))","def to_db(self):\n bulk = conn_db().initialize_ordered_bulk_op()\n for fiction in self.fictions:\n bulk.find({'id': fiction.id}).upsert().update({'$set': fiction.__dict__})\n bulk.execute()","def insert_data(data, collec, many):\n db = client.get_database('tweetstorm')\n collection = db.get_collection(collec)\n if many:\n collection.insert_many(data)\n logger.info(f\"{ymdhms()} inserted {len(data)} tweets to {collec} collection\")\n else:\n collection.insert_one(data)\n logger.info(f\"{ymdhms()} inserted data {data} to {collec} collection\")","def bulk_upsert(self, docs, namespace, timestamp):\n def docs_to_upsert():\n doc = None\n for doc in docs:\n # Remove metadata and redundant _id\n index, doc_type = self._index_and_mapping(namespace)\n doc_id = u(doc.pop(\"_id\"))\n document_action = {\n '_index': index,\n '_type': doc_type,\n '_id': doc_id,\n '_source': self._formatter.format_document(doc)\n }\n document_meta = {\n '_index': self.meta_index_name,\n '_type': self.meta_type,\n '_id': doc_id,\n '_source': {\n 'ns': namespace,\n '_ts': timestamp\n }\n }\n yield document_action\n yield document_meta\n if doc is None:\n raise errors.EmptyDocsError(\n \"Cannot upsert an empty sequence of \"\n \"documents into Elastic Search\")\n try:\n kw = {}\n if self.chunk_size > 0:\n kw['chunk_size'] = self.chunk_size\n\n responses = streaming_bulk(client=self.elastic,\n actions=docs_to_upsert(),\n **kw)\n\n for ok, resp in responses:\n if not ok:\n LOG.error(\n \"Could not bulk-upsert document \"\n \"into ElasticSearch: %r\" % resp)\n if self.auto_commit_interval == 0:\n self.commit()\n except errors.EmptyDocsError:\n # This can happen when mongo-connector starts up, there is no\n # config file, but nothing to dump\n pass","def insert_into_sql(chunk):\n bulk_list = []\n for row in chunk:\n bulk_list.append(StockData(\n date=str(row[0])[0:4] + '-' + str(row[0])[4:6] + '-' + str(row[0])[6:8],\n code=row[1],\n code_name=row[2],\n d1_diff_rate=row[3],\n close=row[4],\n open=row[5],\n high=row[6],\n low=row[7],\n volume=row[8],\n clo5=row[9],\n clo10=row[10],\n clo20=row[11],\n clo40=row[12],\n clo60=row[13],\n clo80=row[14],\n clo100=row[15],\n clo120=row[16],\n clo5_diff_rate=row[17],\n clo10_diff_rate=row[18],\n clo20_diff_rate=row[19],\n clo40_diff_rate=row[20],\n clo60_diff_rate=row[21],\n clo80_diff_rate=row[22],\n clo100_diff_rate=row[23],\n clo120_diff_rate=row[24],\n yes_clo_5=row[25],\n yes_clo_10=row[26],\n yes_clo_20=row[27],\n yes_clo_40=row[28],\n yes_clo_60=row[29],\n yes_clo_80=row[30],\n yes_clo_100=row[31],\n yes_clo_120=row[32],\n vol5=row[33],\n vol10=row[34],\n vol20=row[35],\n vol40=row[36],\n vol60=row[37],\n vol80=row[38],\n vol100=row[39],\n vol120=row[40],\n ))\n StockData.objects.bulk_create(bulk_list)\n return bulk_list","def bulk_upsert(self, data, parameters=None, many_to_many_clear: bool = True):\n elements = []\n\n # Skip if no identifier is set\n if not self.unique_identifier or not data:\n return\n\n for element in data:\n if isinstance(parameters, dict):\n element.update(parameters)\n\n element, created = self.upsert(data=element, many_to_many_clear=many_to_many_clear)\n elements.append(element)\n\n return elements","def execute(self):\n for coll in list(self.__bulks):\n try:\n bulkOp = self.__bulks[coll]\n curr_result = Counter(bulkOp.execute())\n self.update_results(coll, curr_result)\n except BulkWriteError as bwe:\n sys.stderr.write(str(bwe.details))","def bulkSave(self, objList: List[PermissionContext], tokenData: TokenData):","def bulk_create(\n self,\n objs,\n batch_size=None,\n ignore_conflicts=False,\n update_conflicts=False,\n update_fields=None,\n unique_fields=None,\n ):\n # When you bulk insert you don't get the primary keys back (if it's an\n # autoincrement, except if can_return_rows_from_bulk_insert=True), so\n # you can't insert into the child tables which references this. There\n # are two workarounds:\n # 1) This could be implemented if you didn't have an autoincrement pk\n # 2) You could do it by doing O(n) normal inserts into the parent\n # tables to get the primary keys back and then doing a single bulk\n # insert into the childmost table.\n # We currently set the primary keys on the objects when using\n # PostgreSQL via the RETURNING ID clause. It should be possible for\n # Oracle as well, but the semantics for extracting the primary keys is\n # trickier so it's not done yet.\n if batch_size is not None and batch_size <= 0:\n raise ValueError(\"Batch size must be a positive integer.\")\n # Check that the parents share the same concrete model with the our\n # model to detect the inheritance pattern ConcreteGrandParent ->\n # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy\n # would not identify that case as involving multiple tables.\n for parent in self.model._meta.get_parent_list():\n if parent._meta.concrete_model is not self.model._meta.concrete_model:\n raise ValueError(\"Can't bulk create a multi-table inherited model\")\n if not objs:\n return objs\n opts = self.model._meta\n if unique_fields:\n # Primary key is allowed in unique_fields.\n unique_fields = [\n self.model._meta.get_field(opts.pk.name if name == \"pk\" else name)\n for name in unique_fields\n ]\n if update_fields:\n update_fields = [self.model._meta.get_field(name) for name in update_fields]\n on_conflict = self._check_bulk_create_options(\n ignore_conflicts,\n update_conflicts,\n update_fields,\n unique_fields,\n )\n self._for_write = True\n fields = opts.concrete_fields\n objs = list(objs)\n self._prepare_for_bulk_create(objs)\n with transaction.atomic(using=self.db, savepoint=False):\n objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)\n if objs_with_pk:\n returned_columns = self._batched_insert(\n objs_with_pk,\n fields,\n batch_size,\n on_conflict=on_conflict,\n update_fields=update_fields,\n unique_fields=unique_fields,\n )\n for obj_with_pk, results in zip(objs_with_pk, returned_columns):\n for result, field in zip(results, opts.db_returning_fields):\n if field != opts.pk:\n setattr(obj_with_pk, field.attname, result)\n for obj_with_pk in objs_with_pk:\n obj_with_pk._state.adding = False\n obj_with_pk._state.db = self.db\n if objs_without_pk:\n fields = [f for f in fields if not isinstance(f, AutoField)]\n returned_columns = self._batched_insert(\n objs_without_pk,\n fields,\n batch_size,\n on_conflict=on_conflict,\n update_fields=update_fields,\n unique_fields=unique_fields,\n )\n connection = connections[self.db]\n if (\n connection.features.can_return_rows_from_bulk_insert\n and on_conflict is None\n ):\n assert len(returned_columns) == len(objs_without_pk)\n for obj_without_pk, results in zip(objs_without_pk, returned_columns):\n for result, field in zip(results, opts.db_returning_fields):\n setattr(obj_without_pk, field.attname, result)\n obj_without_pk._state.adding = False\n obj_without_pk._state.db = self.db\n\n return objs","def multiple_insertion(self, insert_lists):\n for args in insert_lists:\n self.Log.execute(\n \" \".join(\n [\n \"INSERT IGNORE INTO {} ({})\".format(*args),\n self.build_params_values(args[-1]),\n ]\n ),\n args[-1],\n )","def bulk_process(self):\n\n def actions():\n try:\n task = self.queue.get(block=False, timeout=None)\n\n if task['action'] == 'index':\n yield {\n '_op_type': 'index',\n '_index': self.ensure_index(task),\n '_id': task['id'],\n 'doc': task['properties']\n }\n elif task['action'] == 'delete':\n yield {\n '_op_type': 'delete',\n '_index': self.ensure_index(task),\n '_id': task['id'],\n 'doc': task['properties']\n }\n else:\n raise NotImplementedError\n\n except Empty:\n pass\n\n for success, info in streaming_bulk(self.es_client, actions()):\n if success:\n self.queue.task_done()","def test_core_insert(n):\n with engine.begin() as conn:\n conn.execute(\n Customer.__table__.insert(),\n [\n dict(\n name=\"customer name %d\" % i,\n description=\"customer description %d\" % i,\n )\n for i in range(n)\n ],\n )","def bulk_push_to_elastic(elastic_search_url, index, docs):\n CREATE_TEMPLATE = {\"create\": {\"_index\": index, \"_type\": \"_doc\", \"_id\": \"\"}}\n\n bulk_request_body = \"\"\n for doc in docs:\n CREATE_TEMPLATE[\"create\"][\"_id\"] = doc[HASH_ID]\n bulk_request_body += json.dumps(CREATE_TEMPLATE) + NEW_LINE\n bulk_request_body += json.dumps(doc) + NEW_LINE\n\n # Request\n headers = {\"content-type\": \"application/x-ndjson\"}\n\n url = elastic_search_url + \"/\" + \"_bulk\"\n\n response = requests.post(url, data=bulk_request_body, headers=headers)\n return response"],"string":"[\n \"def _insert_bulk(self, iterable):\\n self.cursor.executemany(self.INSERT, iterable)\\n self.conn.commit()\",\n \"def bulkInsert(self, url, values):\\n pass\",\n \"def insertmany(cls, *args):\\n return InsertQuery(cls).bulk(True).set(*args)\",\n \"def bulk_insert(objects, model, session):\\n session.bulk_insert_mappings(model, objects)\",\n \"def bulk_insert(self, data, insert_option):\\n try:\\n if (insert_option == 'distelec'):\\n self.db[self.distelect_table_or_collection].insert_many(data)\\n\\n elif (insert_option == 'padron'):\\n self.db[self.elector_table_or_collection].insert_many(data)\\n\\n elif (insert_option == 'province_stats'):\\n self.db[self.province_stats_table_or_collection].insert_many(\\n data)\\n\\n elif (insert_option == 'canton_stats'):\\n self.db[self.canton_stats_table_or_collection].insert_many(\\n data)\\n\\n elif (insert_option == 'district_stats'):\\n self.db[self.district_stats_table_or_collection].insert_many(\\n data)\\n\\n print(f\\\"--- The data was inserted ---\\\")\\n\\n except Exception as error:\\n print(error)\",\n \"def insert_data_bulk(self, table_name, data):\\n if len(data) == 0:\\n return\\n\\n fields = \\\", \\\".join(data[0].keys())\\n value_placeholders = \\\", \\\".join([\\\"%s\\\" for f in data[0].keys()])\\n query = \\\"INSERT INTO %s(%s) VALUES (%s)\\\" % (table_name, fields, value_placeholders)\\n\\n data = [tuple(self.pack(data_point.values())) for data_point in data]\\n\\n chunk_size = 50000\\n data_chunks = [data[i:i + chunk_size] for i in range(0, len(data), chunk_size)]\\n for chunk in data_chunks:\\n self.cursor.executemany(query, chunk)\\n self.db_connection.commit()\",\n \"def bulk_insert(engine, model, entries):\\n with session_scope(engine) as session:\\n session.bulk_insert_mappings(model, entries)\\n session.commit()\",\n \"def insert(self, index, documents, batch_size=100):\\n actions = []\\n latest_index_id, begin_timestamp = self.__get_latest_index(index)\\n\\n for idx, doc in enumerate(documents):\\n index_id = latest_index_id\\n\\n if doc[\\\"request_time\\\"] <= begin_timestamp:\\n index_id = self.get_query_index(index, doc[\\\"request_time\\\"])\\n\\n action = {\\n \\\"_index\\\": index + \\\"_\\\" + str(index_id),\\n \\\"_type\\\": \\\"docs\\\",\\n \\\"_source\\\": doc,\\n }\\n actions.append(action)\\n\\n if len(actions) == batch_size or idx == len(documents) - 1:\\n print(\\\"Bulk ingesting started...\\\")\\n\\n try:\\n bulk(self.client, actions, raise_on_error=True, request_timeout=200)\\n except:\\n print(\\\"Could not write the data.\\\")\\n raise\\n \\n actions.clear()\\n print(\\\"Bulk ingesting done\\\")\\n if self.__get_index_size(index, latest_index_id) >= self.THRESHOLD:\\n begin_timestamp = self.__update_index_timerange(\\n index, latest_index_id\\n )\\n latest_index_id = self.__create_new_index(\\n index, latest_index_id + 1, begin_timestamp\\n )\",\n \"def do_bulk(self, args):\\n pass\",\n \"def bulk_insert(cls, path=\\\"data.json\\\"):\\n from json import load\\n from codecs import open\\n \\n lists = load(open(path, \\\"r\\\", \\\"utf8\\\"))\\n for lst in lists:\\n ing = cls(content = lst)\\n ing.put()\",\n \"def insert_bulk(self, frame, table_name, conn=None, index=False, index_label=None, \\n schema=None, chunksize=None, copy=True, auto_adjust=True):\\n\\n table = SQLTable(table_name, self, frame=frame, table_setup=False, index=index,\\n if_exists='append', index_label=index_label, schema=schema)\\n \\n table.insert(conn=conn, bulk=True, chunksize=chunksize, copy=copy, \\n auto_adjust=auto_adjust)\",\n \"def insert(self, table_name, rows, bulk=True):\\n table = self._create_table(table_name)\\n return self._perform_query(table.insert(), rows, bulk)\",\n \"async def bulk_insert(self, documents, alias=None):\\n\\n is_valid = True\\n docs_to_insert = []\\n\\n for document_index, document in enumerate(documents):\\n self.update_field_on_save_values(document, document._id is not None)\\n try:\\n is_valid = is_valid and self.validate_document(document)\\n except Exception:\\n err = sys.exc_info()[1]\\n raise ValueError(\\n \\\"Validation for document %d in the documents you are saving failed with: %s\\\"\\n % (document_index, str(err))\\n )\\n\\n if not is_valid:\\n return\\n\\n docs_to_insert.append(document.to_son())\\n\\n if not is_valid:\\n return\\n\\n doc_ids = await self.coll(alias).insert(docs_to_insert)\\n\\n for object_index, object_id in enumerate(doc_ids):\\n documents[object_index]._id = object_id\\n\\n return documents\",\n \"def test_orm_bulk_insert(n):\\n session = Session(bind=engine)\\n session.execute(\\n insert(Customer),\\n [\\n {\\n \\\"name\\\": \\\"customer name %d\\\" % i,\\n \\\"description\\\": \\\"customer description %d\\\" % i,\\n }\\n for i in range(n)\\n ],\\n )\\n session.commit()\",\n \"async def insert_many(self, models):\\n\\n pass\",\n \"def _batched_insert(\\n self,\\n objs,\\n fields,\\n batch_size,\\n on_conflict=None,\\n update_fields=None,\\n unique_fields=None,\\n ):\\n connection = connections[self.db]\\n ops = connection.ops\\n max_batch_size = max(ops.bulk_batch_size(fields, objs), 1)\\n batch_size = min(batch_size, max_batch_size) if batch_size else max_batch_size\\n inserted_rows = []\\n bulk_return = connection.features.can_return_rows_from_bulk_insert\\n for item in [objs[i : i + batch_size] for i in range(0, len(objs), batch_size)]:\\n if bulk_return and (\\n on_conflict is None or on_conflict == OnConflict.UPDATE\\n ):\\n inserted_rows.extend(\\n self._insert(\\n item,\\n fields=fields,\\n using=self.db,\\n on_conflict=on_conflict,\\n update_fields=update_fields,\\n unique_fields=unique_fields,\\n returning_fields=self.model._meta.db_returning_fields,\\n )\\n )\\n else:\\n self._insert(\\n item,\\n fields=fields,\\n using=self.db,\\n on_conflict=on_conflict,\\n update_fields=update_fields,\\n unique_fields=unique_fields,\\n )\\n return inserted_rows\",\n \"def upload_entities(self, batch):\\n # TODO Include a Do Not Overwrite call\\n results = None\\n atlas_endpoint = self.endpoint_url + \\\"/entity/bulk\\\"\\n\\n payload = AtlasClient._prepare_entity_upload(batch)\\n\\n postBulkEntities = requests.post(\\n atlas_endpoint,\\n json=payload,\\n headers=self.authentication.get_authentication_headers()\\n )\\n\\n results = self._handle_response(postBulkEntities)\\n\\n return results\",\n \"def insert(self, conn, matches: List[Dict], verbose: bool) -> None:\\n for i in range(0, len(matches), self.batch_size):\\n batch = self._get_batch(i, matches)\\n self._insert_json_to_sql(conn, batch, verbose)\",\n \"def insert(self, *args):\\n self.insert_count += 1\\n self.total_ops += 1\\n return super(BulkOperator, self).insert(*args)\",\n \"def chunked_insert(model, items, chunk_size=150):\\n # https://www.sqlite.org/limits.html#max_compound_select\\n with db.atomic():\\n for idx in range(0, len(items), chunk_size):\\n model.insert_many(items[idx:idx+chunk_size]).execute()\",\n \"def post_bulk(bulk_json):\\n\\n nbtry=0\\n success=False\\n\\n # Bulk insert\\n ####################################################################\\n cnx.request(\\\"POST\\\",config.index+\\\"/\\\"+config.typ+\\\"/_bulk\\\",bulk_json) #\\n ####################################################################\\n\\n # Get and read response from Elastic Search server\\n resp=cnx.getresponse()\\n resp_msg_json= resp.read()\\n #sys.stderr.write( resp_msg_json + \\\"\\\\n\\\")\\n resp_msg=json.loads(resp_msg_json)\\n # Check status: both HTTP and within the Elastic Search answer\\n if resp.status != httplib.OK or resp_msg[\\\"errors\\\"] is True:\\n sys.stderr.write( bulk_json)\\n sys.stderr.write( resp_msg_json +\\\"\\\\n\\\")\\n raise Exception(\\\"ERROR when bulk loading into %s/%s: %d %s\\\\n\\\" % (config.index,config.typ, resp.status, resp.reason))\",\n \"def batch_execute(self, conn):\\n def batches(data, batch_size) -> list:\\n \\\"\\\"\\\"Return batches of length `batch_size` from any object that\\n supports iteration without knowing length.\\\"\\\"\\\"\\n rv = []\\n for idx, line in enumerate(data):\\n if idx != 0 and idx % batch_size == 0:\\n yield rv\\n rv = []\\n rv.append(line)\\n yield rv\\n\\n columns = ColumnCollection(self.columns)\\n if self.header:\\n self.columns = [columns.get(h) for h in next(self.data)]\\n columns = ColumnCollection(self.columns)\\n\\n total = 0\\n query = BulkInsertQuery(self.table, columns)\\n for batch in batches(self.data, self.batch_size):\\n total += query.execute(conn, batch) or 0\\n yield total\",\n \"def bulk_copy_to_db(self):\\n database = PostgreSQLCommon()\\n\\n try:\\n file = open(self.file_name_hash)\\n database.bulk_copy(file, self.storage_table)\\n\\n m.info('Bulk insert from %s has been successfully completed!'\\n % self.file_name_hash)\\n except Exception as err:\\n m.error('OOps! Bulk insert operation FAILED! Reason: %s' % str(err))\\n finally:\\n database.close()\\n\\n if os.path.exists(self.file_name_hash):\\n os.remove(self.file_name_hash)\",\n \"def insert_many(collection, data):\\n try:\\n return collection.insert_many(data).inserted_ids\\n except Exception as error:\\n print(error)\\n raise\",\n \"def insert_data_many(settings_filename, query_filename, data_list):\\n conn = connect_to_db(settings_filename)\\n cursor = conn.cursor()\\n \\n query = load_query(query_filename)\\n cursor.prepare(query)\\n logging.debug(query)\\n cursor.executemany(None, data_list)\\n conn.commit()\\n \\n cursor.close()\\n conn.close()\\n\\n return True\",\n \"def bulk_insert(cls, device_id, imeis):\\n insertion_object = []\\n for imei in imeis:\\n insertion_object.append({'imei': imei, 'normalized_imei': imei[0:14], 'device_id': device_id})\\n res = db.engine.execute(ImeiDevice.__table__.insert(), insertion_object)\\n res.close()\",\n \"def thread_insert_data(collection_to_insert, collection_name):\\n for item in collection_to_insert:\\n insert_data_to_collection(item, collection_name)\",\n \"def _bulk_add_rows(self, converted) :\\n\\n insert_sql = 'INSERT INTO \\\"%s\\\" VALUES (%s)' % (self.name, ','.join(['?'] * len(self.cols)))\\n cur = self.con.cursor()\\n cur.executemany(insert_sql, converted)\",\n \"def _batch_insert(bq_client, table, rows):\\n total_rows = len(rows)\\n inserted_rows = 0\\n batch = 1\\n logger.info(\\\"Inserting %d rows into table %s\\\", total_rows,\\n table.full_table_id)\\n while inserted_rows < total_rows:\\n start = (batch - 1) * MAX_BQ_INSERT_SIZE\\n end = batch * MAX_BQ_INSERT_SIZE\\n batch_rows = rows[start:end]\\n inserted_rows += len(batch_rows)\\n errors = _insert_rows(bq_client, table, batch_rows)\\n if errors:\\n print_bq_insert_errors(batch_rows, errors)\\n logger.error(\\n \\\"The program has been terminated due to BigQuery insertion \\\"\\n \\\"errors.\\\")\\n exit(1)\\n else:\\n logger.info(\\\"Batch %d: inserted rows %d to %d\\\", batch, start + 1,\\n min(end, len(rows)))\\n batch += 1\\n logger.info(\\\"All rows inserted.\\\")\",\n \"def bulk_insert(self, file):\\n \\n self.feed_type.ad_mapper.iter_from_file(file)\\n\\n max_pending = 10000 # Max INSERTs pending to commit\\n current_pending = 0 # count the number of ads processing from the xml\\n inserted_ads = 0\\n\\n info = {'status': None, 'file': file, 'inserted': None, 'e_msg': None}\\n pending_raw_ads = []\\n record_ids = []\\n old_ads = 0\\n repeated_ads = 0\\n while True:\\n try:\\n raw_ad = RawAd()\\n raw_ad.raw_content = self.feed_type.ad_mapper.get_raw_content()\\n raw_ad.feed_in = self\\n\\n ######################## Begin - Filter section ################################\\n # @TODO: Filters should be dinamic. E.g: implement some kind of observer pattern\\n date_info = self.feed_type.ad_mapper.exec_method(\\\"FECHA\\\", raw_ad = raw_ad)\\n days = (dtt.today() - dtt.strptime(date_info[\\\"date\\\"], date_info[\\\"_format\\\"])).days \\n ######################## End - Filter section ################################\\n\\n\\n if days > 30:\\n old_ads += 1\\n continue # It skips the remaining code in the loop. \\n # This way we don't call to database in each iteration \\n\\n\\n ######################## Begin - Filter section ################################\\n # @TODO: Filters should be dinamic. E.g: implement some kind of observer pattern\\n id = self.feed_type.ad_mapper.exec_method(\\\"ID\\\", raw_ad = raw_ad)[\\\"_id_in_feed\\\"]\\n record_id = id + \\\",\\\" + self.feed_type.ad_mapper.exec_method(\\\"URL\\\", raw_ad = raw_ad)[\\\"link\\\"]\\n ad_exists = DBSession.execute(\\\"SELECT 1 FROM fp_feeds_in_records WHERE id = :id\\\", {\\\"id\\\": record_id}).first()\\n ######################## End - Filter section ################################\\n if ad_exists:\\n repeated_ads += 1\\n else:\\n pending_raw_ads.append(\\n {\\n \\\"raw_ad\\\": raw_ad.raw_content,\\n \\\"feed_in_id\\\": self.id\\n })\\n\\n record_ids.append({\\\"id\\\": record_id})\\n\\n current_pending += 1\\n \\n if( current_pending == max_pending):\\n self.__insert(pending_raw_ads, record_ids)\\n\\n inserted_ads += current_pending\\n current_pending = 0\\n\\n except StopIteration:\\n if(current_pending != 0):\\n self.__insert(pending_raw_ads, record_ids)\\n \\n inserted_ads += current_pending\\n current_pending = 0\\n\\n # It updates the processed date's feed\\n self.last_processed_date = date.today()\\n DBSession.commit()\\n \\n info['status'] = 'ok'\\n info['inserted'] = inserted_ads\\n info['repeated_ads'] = repeated_ads\\n info['old_ads'] = old_ads\\n\\n return info\\n\\n except Exception as e:\\n info['status'] = type(e).__name__\\n info['inserted'] = inserted_ads\\n info['e_msg'] = str(e)\\n info['repeated_ads'] = repeated_ads\\n info['old_ads'] = old_ads\\n\\n return info\",\n \"def insert_multiple_db_entries(self, _collection=None, _db_entries=None):\\n assert _collection is not None, 'Must specify collection'\\n assert _db_entries is not None, 'Must specify documents'\\n try:\\n # ordered=False ensures that every insert operation will be attempted\\n # so that if, e.g., a document already exists, it will be simply skipped\\n self.db['db'][_collection].insert_many(_db_entries, ordered=False)\\n except pymongo.errors.BulkWriteError as bwe:\\n print(*time_stamps(), bwe.details)\\n except Exception as _e:\\n traceback.print_exc()\\n print(_e)\",\n \"def insert_json(table=None,\\n bulk_size=1000,\\n concurrency=25,\\n hosts=None,\\n infile=None,\\n output_fmt=None):\\n if not hosts:\\n return print_only(infile, table)\\n\\n queries = (to_insert(table, d) for d in dicts_from_lines(infile))\\n bulk_queries = as_bulk_queries(queries, bulk_size)\\n print('Executing inserts: bulk_size={} concurrency={}'.format(\\n bulk_size, concurrency), file=sys.stderr)\\n\\n stats = Stats()\\n with clients.client(hosts, concurrency=concurrency) as client:\\n f = partial(aio.measure, stats, client.execute_many)\\n try:\\n aio.run_many(f, bulk_queries, concurrency)\\n except clients.SqlException as e:\\n raise SystemExit(str(e))\\n try:\\n print(format_stats(stats.get(), output_fmt))\\n except KeyError:\\n if not stats.sampler.values:\\n raise SystemExit('No data received via stdin')\\n raise\",\n \"def test_select_bulk_insert_transfer(self, *args):\\n task = VerticaToMySqlTransfer(task_id='test_task_id',\\n sql='select a, b, c',\\n mysql_table='test_table',\\n vertica_conn_id='test_vertica_conn_id',\\n mysql_conn_id='test_mysql_conn_id',\\n params={},\\n bulk_load=True,\\n dag=self.dag)\\n task.execute(None)\",\n \"def ingest(self, items: list):\\n if not items:\\n logging.info(f\\\"{self.__class__.__name__} : no `items` to store into database.\\\")\\n return\\n\\n threads = list()\\n\\n for index, item in enumerate(items):\\n logging.info(f\\\"{self.__class__.__name__} : create and start thread {index}.\\\")\\n x = threading.Thread(target=self.validate_and_insert, args=(index,))\\n threads.append(x)\\n x.start()\\n\\n for index, thread in enumerate(threads):\\n logging.info(f\\\"{self.__class__.__name__} : before joining thread {index}.\\\")\\n thread.join()\\n logging.info(f\\\"{self.__class__.__name__} : thread {index} done\\\")\",\n \"def report_bulk(results):\\n from pprint import pprint\\n pprint(results)\\n if results.get('writeConcernErrors', []) or results.get('writeErrors', []):\\n raise BulkFailure(\\\"Failed on bulk insertion\\\")\",\n \"def _load_elastic(self, sqldata):\\n inserts = []\\n for r in sqldata:\\n body = self._preprocess(dict(r.items()))\\n if not body:\\n continue # Skip if preprocessing returns False\\n index_name = self._get_index_name(body['TIME_STAMP'])\\n document = {\\n \\\"_index\\\" : index_name,\\n \\\"_type\\\" : 'default', # Hardcoded - we only have 1 doctype\\n \\\"_id\\\" : body[self.seq_field],\\n \\\"_source\\\" : body\\n }\\n inserts.append(document)\\n\\n # update sequence to last item in the results\\n self.seq = sqldata[-1][self.seq_field]\\n \\n # Insert list of documents into elasticsearch\\n status = helpers.bulk(self.es, inserts, self.chunk_size)\\n self.logger.info(\\\"Inserted %d chunks into %s\\\" % (self.chunk_size,\\n index_name))\\n return status\",\n \"def test_insert_batch(self, queue_mock):\\n from sosbeacon.utils import insert_tasks\\n\\n tasks = []\\n for i in xrange(1, 10):\\n tasks.append(object())\\n added = insert_tasks(tasks, 'default')\\n self.assertEqual(added, 9)\",\n \"def insert(cls, values):\\n result = yield InsertQuery(cls, values).execute()\\n returnValue(result)\",\n \"def load_data(connection, insert_sql, data):\\n cur = connection.cursor()\\n for d in data:\\n cur.execute(insert_sql, d)\\n connection.commit()\",\n \"def test_issue_288(self):\\n conn = self.connect()\\n cursor = conn.cursor()\\n data = [(0, \\\"bob\\\", 21, 123), (1, \\\"jim\\\", 56, 45), (2, \\\"fred\\\", 100, 180)]\\n cursor.executemany(\\n \\\"\\\"\\\"insert\\ninto bulkinsert (id, name,\\nage, height)\\nvalues (%s,\\n%s , %s,\\n%s ) on duplicate key update\\nage = values(age)\\n \\\"\\\"\\\",\\n data,\\n )\\n self.assertEqual(\\n cursor._executed.strip(),\\n bytearray(\\n b\\\"\\\"\\\"insert\\ninto bulkinsert (id, name,\\nage, height)\\nvalues (0,\\n'bob' , 21,\\n123 ),(1,\\n'jim' , 56,\\n45 ),(2,\\n'fred' , 100,\\n180 ) on duplicate key update\\nage = values(age)\\\"\\\"\\\"\\n ),\\n )\\n cursor.execute(\\\"commit\\\")\\n self._verify_records(data)\",\n \"def load_variant_bulk(self, variants):\\n if len(variants) == 0:\\n return\\n\\n LOG.debug(\\\"Loading variant bulk\\\")\\n try:\\n result = self.variant_collection.insert_many(variants)\\n except (DuplicateKeyError, BulkWriteError) as err:\\n # If the bulk write is wrong there are probably some variants already existing\\n # In the database. So insert each variant\\n LOG.warning(\\\"Bulk insertion failed - attempting separate variant upsert for this bulk\\\")\\n for var_obj in variants:\\n try:\\n self.upsert_variant(var_obj)\\n except IntegrityError as err:\\n pass\\n\\n return\",\n \"def insert_records(self, insert_query, insert_query_columns, wiki_data, table_name):\\n print(\\\"Inserting {} rows into {}\\\".format(len(wiki_data), table_name))\\n for index, item in enumerate(wiki_data):\\n values_to_insert = [item[column]['value'] for column in insert_query_columns]\\n try:\\n self.cur.execute(insert_query, values_to_insert)\\n except ValueError as ve:\\n print(\\\"Could not execute query : {} with values\\\".format(insert_query, values_to_insert))\\n raise ve\\n\\n if index % 1000 == 0:\\n print(\\\"Inserted {} rows\\\".format(index))\\n print(\\\"Inserted {} rows\\\".format(len(wiki_data)))\\n print(\\\"Finished inserting {}\\\".format(table_name))\",\n \"def insert_many_execute(self) -> None:\\n self.connection.isolation_level = None\\n self.cursor.execute('BEGIN TRANSACTION')\\n for i in self.__sql_buffer.split(';'):\\n self.cursor.execute(i)\\n self.__sql_buffer = \\\"\\\"\\n self.cursor.execute('COMMIT')\",\n \"def insert(db_name, collection_name, docs):\\n db = client[db_name]\\n collection = db[collection_name]\\n return collection.insert_many(docs)\",\n \"def insert_data(stored_data, table_name):\\r\\n for item in stored_data:\\r\\n cursor.execute('''INSERT INTO {} VALUES(?, ?, ?, ?)'''.format(table_name), item)\",\n \"def insert_many(self, frame, table_name, conn=None, index=False, index_label=None, \\n schema=None, chunksize=None, copy=True, auto_adjust=True):\\n \\n table = SQLTable(table_name, self, frame=frame, table_setup=False, index=index,\\n if_exists='append', index_label=index_label, schema=schema)\\n \\n table.insert(conn=conn, bulk=False, chunksize=chunksize, copy=copy, \\n auto_adjust=auto_adjust)\",\n \"def store_index(self, index, doc_type, source_list, init_id):\\n\\n bulk_actions = []\\n doc_id = init_id\\n\\n for source in source_list:\\n data_body = ElasticSearchUtility.__index_data_body(index, doc_type, doc_id, source[\\\"_source\\\"])\\n bulk_actions.append(data_body)\\n doc_id += 1\\n\\n print 'inserting - ', len(bulk_actions)\\n helpers.bulk(self.es, bulk_actions)\",\n \"def bq_insert_rows(bq_client, table, rows):\\n _batch_insert(bq_client, table, rows)\",\n \"def insert(self, json_data, batch=None):\\n headers = {'Content-type': 'application/json;charset=UTF-8'}\\n url = '/'.join([self.url, self.db])\\n time.sleep(0.01)\\n if batch:\\n r = requests.post(url, data=json_data, headers=headers, params={'batch': 'ok'})\\n else:\\n r = requests.post(url, data=json_data, headers=headers) \\n time.sleep(0.01)\\n if not r.status_code in (201, 202):\\n raise Exception(\\\"HTTP \\\" + str(r.status_code))\",\n \"def insert_data(settings_filename, query_filename, row_list):\\n conn = connect_to_db(settings_filename)\\n cursor = conn.cursor()\\n\\n query = load_query(query_filename)\\n cursor.execute(query,row_list)\\n conn.commit()\\n \\n cursor.close()\\n conn.close()\\n\\n return True\",\n \"def insert_boost(connection: DBConnection, documents: Sequence[Document]) -> None:\\n max_ = len(documents)\\n current = 0\\n print() # print an extra line, because we will delete lines with printing \\\\r\\n for chunk in chunks(documents):\\n\\n connection.execute(\\\"BEGIN TRANSACTION\\\")\\n for doc in chunk:\\n connection.execute(\\n \\\"INSERT INTO boost(did, date, page) VALUES (?, ?, ?)\\\", (doc.id, doc.date, doc.page))\\n connection.execute(\\\"COMMIT\\\")\\n current += len(chunk)\\n print(f\\\"\\\\r[{current}/{max_}] boost done\\\", end='')\\n print()\",\n \"def db_insertmany(table: str, columns: list, values: list):\\n\\n db, c = start_db()\\n\\n cols = ', '.join(columns)\\n vals = ', '.join(['?' for _ in values[0]])\\n query = f'INSERT INTO {table} ({cols}) VALUES ({vals})'\\n\\n c.executemany(query, values)\\n db.commit()\\n db.close()\",\n \"def insert_tfs(connection: DBConnection, documents: Sequence[Document]) -> None:\\n max_ = len(documents)\\n current = 0\\n print() # print an extra line, because we will delete lines with printing \\\\r\\n for chunk in chunks(documents):\\n rows = (d.get_tfs_rows() for d in chunk)\\n connection.execute(\\\"BEGIN TRANSACTION\\\")\\n for row in rows:\\n connection.executemany(\\n \\\"INSERT INTO tfs(did, term, tf) VALUES (?, ?, ?)\\\", row)\\n connection.execute(\\\"COMMIT\\\")\\n current += len(chunk)\\n print(f\\\"\\\\r[{current}/{max_}] doc-tfs done\\\", end='')\\n print()\",\n \"def insert_documents(connection: DBConnection, documents: Sequence[Document]) -> None:\\n max_ = len(documents)\\n current = 0\\n print() # print an extra line, because we will delete lines with printing \\\\r\\n for chunk in chunks(documents):\\n connection.execute(\\\"BEGIN TRANSACTION\\\")\\n for doc in chunk:\\n # python doesn't support prepared statements, but instead has a builtin sql cache\\n connection.execute(\\n \\\"INSERT INTO docs(did, title, url) VALUES (?, ?, ?)\\\", doc.convert_to_tuple())\\n current += 1\\n print(f\\\"\\\\r[{current}/{max_}] doc done\\\", end='')\\n connection.execute(\\\"COMMIT\\\")\",\n \"def insertmany(self, table, values):\\n col_name = self.table_cols[table][1:]\\n sql = 'INSERT INTO %s(%s) VALUES (%s)' % (table, ','.join(col_name), ','.join(['%s'] * len(values[0])))\\n Log.debug('DB -> %s' % sql)\\n self.execute(sql, values)\",\n \"def execute_many(self, query: str, args):\\n return self.insert_many(query, args)\",\n \"def insert_data(self, table_name, data):\\n for data_point in data:\\n query = \\\"INSERT INTO %s(%s) VALUES (%s)\\\"\\n\\n fields = \\\", \\\".join(data_point.keys())\\n values = \\\", \\\".join([self.pack_data(value) for value in data_point.values()])\\n self.cursor.execute(query % (table_name, fields, values))\\n self.db_connection.commit()\",\n \"def write(self, batch):\\n cursor = connection.cursor()\\n while batch:\\n values = [\\n \\\"(%s, %s)\\\" % (\\n psycopg2.Binary(k),\\n psycopg2.Binary(v)\\n ) for k, v in batch[:self.BATCH_SIZE]]\\n sql = \\\"INSERT INTO %s(k,v) VALUES %s\\\" % (self.table, \\\",\\\".join(values))\\n batch = batch[self.BATCH_SIZE:]\\n cursor.execute(sql)\\n cursor.execute(\\\"COMMIT\\\")\",\n \"def upload(\\n workspace: str, table: str, key: str = \\\"_key\\\", overwrite: bool = False\\n) -> Any:\\n space = db.get_workspace_db(workspace, readonly=False)\\n if space.has_collection(table):\\n raise AlreadyExists(\\\"table\\\", table)\\n\\n app.logger.info(\\\"Bulk Loading\\\")\\n\\n # Read the request body into CSV format\\n body = decode_data(request.data)\\n\\n try:\\n # Type to a Dict rather than an OrderedDict\\n rows: List[Dict[str, str]] = list(csv.DictReader(StringIO(body)))\\n except csv.Error:\\n raise CSVReadError()\\n\\n # Perform validation.\\n validate_csv(rows, key, overwrite)\\n\\n # Once we reach here, we know that the specified key field must be present,\\n # and either:\\n # key == \\\"_key\\\" # noqa: E800\\n # or key != \\\"_key\\\" and the \\\"_key\\\" field is not present\\n # or key != \\\"_key\\\" and \\\"_key\\\" is present, but overwrite = True\\n if key != \\\"_key\\\":\\n rows = set_table_key(rows, key)\\n\\n # Set the collection, paying attention to whether the data contains\\n # _from/_to fields.\\n fieldnames = rows[0].keys()\\n edges = \\\"_from\\\" in fieldnames and \\\"_to\\\" in fieldnames\\n coll = space.create_collection(table, edge=edges)\\n\\n # Insert the data into the collection.\\n results = coll.insert_many(rows)\\n return {\\\"count\\\": len(results)}\",\n \"def test_bulk_insert(self):\\n\\n class Comment(EmbeddedDocument):\\n name = StringField()\\n\\n class Post(EmbeddedDocument):\\n comments = ListField(EmbeddedDocumentField(Comment))\\n\\n class Blog(Document):\\n title = StringField(unique=True)\\n tags = ListField(StringField())\\n posts = ListField(EmbeddedDocumentField(Post))\\n\\n Blog.drop_collection()\\n\\n # Recreates the collection\\n assert 0 == Blog.objects.count()\\n\\n comment1 = Comment(name=\\\"testa\\\")\\n comment2 = Comment(name=\\\"testb\\\")\\n post1 = Post(comments=[comment1, comment2])\\n post2 = Post(comments=[comment2, comment2])\\n\\n # Check bulk insert using load_bulk=False\\n blogs = [Blog(title=\\\"%s\\\" % i, posts=[post1, post2]) for i in range(99)]\\n with query_counter() as q:\\n assert q == 0\\n Blog.objects.insert(blogs, load_bulk=False)\\n assert q == 1 # 1 entry containing the list of inserts\\n\\n assert Blog.objects.count() == len(blogs)\\n\\n Blog.drop_collection()\\n Blog.ensure_indexes()\\n\\n # Check bulk insert using load_bulk=True\\n blogs = [Blog(title=\\\"%s\\\" % i, posts=[post1, post2]) for i in range(99)]\\n with query_counter() as q:\\n assert q == 0\\n Blog.objects.insert(blogs)\\n assert q == 2 # 1 for insert 1 for fetch\\n\\n Blog.drop_collection()\\n\\n comment1 = Comment(name=\\\"testa\\\")\\n comment2 = Comment(name=\\\"testb\\\")\\n post1 = Post(comments=[comment1, comment2])\\n post2 = Post(comments=[comment2, comment2])\\n blog1 = Blog(title=\\\"code\\\", posts=[post1, post2])\\n blog2 = Blog(title=\\\"mongodb\\\", posts=[post2, post1])\\n blog1, blog2 = Blog.objects.insert([blog1, blog2])\\n assert blog1.title == \\\"code\\\"\\n assert blog2.title == \\\"mongodb\\\"\\n\\n assert Blog.objects.count() == 2\\n\\n # test inserting an existing document (shouldn't be allowed)\\n with pytest.raises(OperationError) as exc_info:\\n blog = Blog.objects.first()\\n Blog.objects.insert(blog)\\n assert (\\n str(exc_info.value)\\n == \\\"Some documents have ObjectIds, use doc.update() instead\\\"\\n )\\n\\n # test inserting a query set\\n with pytest.raises(OperationError) as exc_info:\\n blogs_qs = Blog.objects\\n Blog.objects.insert(blogs_qs)\\n assert (\\n str(exc_info.value)\\n == \\\"Some documents have ObjectIds, use doc.update() instead\\\"\\n )\\n\\n # insert 1 new doc\\n new_post = Blog(title=\\\"code123\\\", id=ObjectId())\\n Blog.objects.insert(new_post)\\n\\n Blog.drop_collection()\\n\\n blog1 = Blog(title=\\\"code\\\", posts=[post1, post2])\\n blog1 = Blog.objects.insert(blog1)\\n assert blog1.title == \\\"code\\\"\\n assert Blog.objects.count() == 1\\n\\n Blog.drop_collection()\\n blog1 = Blog(title=\\\"code\\\", posts=[post1, post2])\\n obj_id = Blog.objects.insert(blog1, load_bulk=False)\\n assert isinstance(obj_id, ObjectId)\\n\\n Blog.drop_collection()\\n post3 = Post(comments=[comment1, comment1])\\n blog1 = Blog(title=\\\"foo\\\", posts=[post1, post2])\\n blog2 = Blog(title=\\\"bar\\\", posts=[post2, post3])\\n Blog.objects.insert([blog1, blog2])\\n\\n with pytest.raises(NotUniqueError):\\n Blog.objects.insert(Blog(title=blog2.title))\\n\\n assert Blog.objects.count() == 2\",\n \"def insert_many(self, conn, key, **kwargs):\\n conn.zadd(key, **kwargs)\",\n \"def insert_data(self) -> None:\\n if self.min_insert_size > self.insert_count:\\n LOG.debug(\\\"Not enough data for insert....\\\")\\n return\\n LOG.debug(f'Inserting {self.insert_count} records...')\\n self.insert.write(self.copy_trailer)\\n self.insert.seek(0)\\n conn = pg.connect(self.dsn)\\n with conn.cursor() as cur:\\n cur.copy_expert(self.cmd, self.insert)\\n conn.commit()\\n conn.close()\\n self.insert.close()\\n self.create_byte_buffer()\",\n \"def batch_insert_direct(self, data, *args, **kwargs):\\n return pycassa.ColumnFamily.batch_insert(self, data, *args, **kwargs)\",\n \"def bulkupload_entitie_records(self, entity_upload_parameters, tmp_file, progress=None):\\n records = self.service_client.factory.create(\\\"ns2:ArrayOfstring\\\")\\n tmp_csv_file = io.open(tmp_file, encoding='utf-8-sig')\\n\\n records.string = [x.strip() for x in tmp_csv_file.readlines()]\\n \\n try:\\n #print(self.service_client)\\n response = self.service_client.UploadEntityRecords(\\n AccountId=self._authorization_data.account_id,\\n EntityRecords=records,\\n ResponseMode=entity_upload_parameters.response_mode\\n )\\n if self.need_to_fall_back_to_async(response):\\n headers = self.service_client.get_response_header()\\n operation = BulkUploadOperation(\\n request_id=response.RequestId,\\n authorization_data=self._authorization_data,\\n poll_interval_in_milliseconds=self._poll_interval_in_milliseconds,\\n environment=self._environment,\\n tracking_id=headers['TrackingId'] if 'TrackingId' in headers else None,\\n **self.suds_options\\n )\\n file_path = self.download_upload_result(operation, entity_upload_parameters, progress)\\n return self.read_result_from_bulk_file(file_path)\\n else:\\n return self.read_bulkupsert_response(response) \\n except Exception as ex:\\n if 'OperationNotSupported' == operation_errorcode_of_exception(ex):\\n return self.bulkupload_entities(entity_upload_parameters, tmp_file, progress)\\n else:\\n raise ex\",\n \"def upload_entities(self, entity_upload_parameters, progress=None):\\n \\n tmp_file = path.join(self.working_directory, '{0}.csv'.format(uuid.uuid1()))\\n with BulkFileWriter(tmp_file) as writer:\\n for entity in entity_upload_parameters.entities:\\n writer.write_entity(entity)\\n\\n if (self.need_to_try_upload_entity_records_sync_first(entity_upload_parameters)):\\n return self.bulkupload_entitie_records(entity_upload_parameters, tmp_file, progress)\\n else:\\n return self.bulkupload_entities(entity_upload_parameters, tmp_file, progress)\",\n \"def insert_many(self, data: list[dict], db_name: str = None, collection_name: str = None, **kwargs) -> bool:\\n db: Database = self.db if db_name is None else self.client[db_name]\\n coll: Collection = self.coll if collection_name is None else db[collection_name]\\n \\n coll.insert_many(data)\\n\\n return True\",\n \"def insert(self, items=''):\\n cur = self.conn.cursor()\\n\\n format_args = {'table': self.__name__,\\n 'items': ', '.join(items.keys()),\\n 'values': ', '.join([':'+key for key in items.keys()])}\\n \\n insert_query = \\\"\\\"\\\"\\n INSERT INTO {table} ({items}) VALUES ({values})\\n \\\"\\\"\\\".format(**format_args)\\n\\n cur.execute(insert_query, items)\",\n \"async def test_valid_insert_batch(database,valid_data):\\n await database.setup_database(reset=True)\\n data = []\\n for _id,user_id,embeddings,batch_id in valid_data: #pylint: disable=unused-variable\\n await database.insert_user(user_id)\\n data.append((_id,user_id,embeddings,1))\\n await database.insert_batch(data)\\n await database.close_pool()\",\n \"def elastic_data_sync(from_ts, to_ts, conn_obj, idx, type):\\n if from_ts:\\n query = {\\\"_id\\\": {\\\"$gt\\\": from_ts, \\\"$lte\\\": to_ts}}\\n else:\\n query = {\\\"_id\\\": {\\\"$lte\\\": to_ts}}\\n pkg_meta = conn_obj.find(query)\\n #Call elasticsearch bulk insert with mongo cursor\\n data = {\\\"data_iter\\\": pkg_meta, \\\"index\\\": idx, \\\"_type\\\": type,\\n \\\"mapping\\\": ELASTIC_MAPPINGS.get(idx, {})}\\n es_sync = ElasticSearch()\\n status, res = es_sync.bulk(**data)\\n return status, res\",\n \"def multiple_insert(self, tablename, values, seqname=None, _test=False): \\n if not values:\\n return []\\n \\n if not self.supports_multiple_insert:\\n out = [self.insert(tablename, seqname=seqname, _test=_test, **v) for v in values]\\n if seqname is False:\\n return None\\n else:\\n return out\\n \\n keys = values[0].keys()\\n #@@ make sure all keys are valid\\n\\n for v in values:\\n if v.keys() != keys:\\n raise ValueError, 'Not all rows have the same keys'\\n\\n sql_query = SQLQuery('INSERT INTO %s (%s) VALUES ' % (tablename, ', '.join(keys)))\\n\\n for i, row in enumerate(values):\\n if i != 0:\\n sql_query.append(\\\", \\\")\\n SQLQuery.join([SQLParam(row[k]) for k in keys], sep=\\\", \\\", target=sql_query, prefix=\\\"(\\\", suffix=\\\")\\\")\\n \\n if _test: return sql_query\\n\\n db_cursor = self._db_cursor()\\n if seqname is not False: \\n sql_query = self._process_insert_query(sql_query, tablename, seqname)\\n\\n if isinstance(sql_query, tuple):\\n # for some databases, a separate query has to be made to find \\n # the id of the inserted row.\\n q1, q2 = sql_query\\n self._db_execute(db_cursor, q1)\\n self._db_execute(db_cursor, q2)\\n else:\\n self._db_execute(db_cursor, sql_query)\\n\\n try: \\n out = db_cursor.fetchone()[0]\\n out = range(out-len(values)+1, out+1) \\n except Exception: \\n out = None\\n\\n if not self.ctx.transactions: \\n self.ctx.commit()\\n return out\",\n \"def insertall(self, rows):\\n method = 'tabledata().insertAll().execute()'\\n body = {}\\n body['rows'] = [{'json': row} for row in rows]\\n body[\\\"kind\\\"] = \\\"bigquery#tableDataInsertAllRequest\\\"\\n return self._make_request(method, body)\",\n \"def linear(files):\\n return list(map(insert_to_mongo, files))\",\n \"def insert_(statement: str, db_conf) -> []:\\n try:\\n result = db_conf.execute(statement)\\n if result:\\n return result\\n except psycopg2.IntegrityError:\\n pass\\n return []\",\n \"def bulk_index(data):\\n\\n def bulk_api_string(item):\\n return f\\\"{{\\\\\\\"index\\\\\\\":{{}}\\\\n{json.dumps(item)}\\\"\\n\\n body = '\\\\n'.join([bulk_api_string(item) for item in data]) + '\\\\n'\\n\\n return make_request(\\n requests.post,\\n url=f\\\"{connection.hostname}:{connection.port}/{connection.index}/_bulk\\\",\\n headers={'Content-Type': 'application/json'},\\n auth=auth,\\n data=body\\n )\",\n \"def load_fixtures(self, dbname, table, data):\\n db = self.databases[dbname]['db']\\n db.execute('BEGIN')\\n for row in data:\\n columns = row.keys()\\n q = db.Insert(table, cols=columns)\\n db.execute(q, row)\\n db.execute('COMMIT')\",\n \"def bulk_insert_into_table(cursor, operation, cnx, \\n mute=True, autocommit=True): \\n op_list=re.split(';\\\\s*',operation)\\n count=0\\n for op in op_list:\\n if mute:\\n try:\\n cursor.execute(op)\\n if autocommit:\\n if not cnx.autocommit:\\n cnx.commit()\\n result = cursor\\n count += result.rowcount\\n print(\\\"Warnings: \\\" + str(result.fetchwarnings()) + \\\".\\\")\\n except mysql.connector.Error as err:\\n print(err.msg + \\\".\\\")\\n else:\\n try:\\n cursor.execute(op)\\n if autocommit:\\n if not cnx.autocommit:\\n cnx.commit()\\n result = cursor\\n print(f\\\"Number of rows affected by statement \\\"\\n f\\\"'{result.statement}': {result.rowcount}.\\\")\\n print(\\\"Warnings: \\\" + str(result.fetchwarnings()) + \\\".\\\")\\n except mysql.connector.Error as err:\\n print(err.msg + \\\".\\\")\\n if mute:\\n print(f\\\"Number of rows affected by statement: {count}.\\\")\\n print(\\\"Done Inserting.\\\")\",\n \"def bulk(self) -> None:\\n helpers.bulk(self.client, self.gen_business_data(BUSINESS_FP))\\n helpers.bulk(self.client, self.gen_review_data(REVIEW_FP))\\n helpers.bulk(self.client, self.gen_tip_data(TIP_FP))\",\n \"def test_bulk_observable_add(self):\\n observables = [\\\"{}{}.com\\\".format(_random_domain(), i) for i in range(20)]\\n info = self.api.observable_bulk_add(observables, ['bulk'])\\n self.assertEqual(len(info), 20)\",\n \"def _insert(\\n self,\\n objs,\\n fields,\\n returning_fields=None,\\n raw=False,\\n using=None,\\n on_conflict=None,\\n update_fields=None,\\n unique_fields=None,\\n ):\\n self._for_write = True\\n if using is None:\\n using = self.db\\n query = sql.InsertQuery(\\n self.model,\\n on_conflict=on_conflict,\\n update_fields=update_fields,\\n unique_fields=unique_fields,\\n )\\n query.insert_values(fields, objs, raw=raw)\\n return query.get_compiler(using=using).execute_sql(returning_fields)\",\n \"async def insert(self, args: Dict[str, Any]):\\n keys = \\\", \\\".join(args.keys())\\n values = \\\", \\\".join([f\\\"${i + 1}\\\" for i in range(len(args))])\\n\\n conn: Connection\\n async with self.db_pool.acquire() as conn:\\n await conn.execute(\\n f\\\"INSERT INTO {self.table_name} \\\"\\n f\\\"({keys}) VALUES ({values})\\\",\\n *args.values(),\\n )\",\n \"def bulkCreateTasks(request, *args, **kwargs):\\n import settings\\n\\n # keep track of our own timelimit (20 seconds)\\n timelimit = 20000\\n timekeeper = Timekeeper(timelimit)\\n\\n post_dict = request.POST\\n\\n bulk_create_key = post_dict.get('bulk_create_key')\\n if not bulk_create_key:\\n return error_handler.logErrorAndReturnOK(\\n 'Not all POST data specified in: %s' % post_dict)\\n\\n bulk_data = bulk_create_model.GCIBulkCreateData.get(bulk_create_key)\\n if not bulk_data:\\n return error_handler.logErrorAndReturnOK(\\n 'No valid data found for key: %s' % bulk_create_key)\\n\\n # note that we only query for the quota once\\n org_admin = bulk_data.created_by\\n task_quota = org_logic.getRemainingTaskQuota(org_admin.scope)\\n\\n tasks = bulk_data.tasks\\n while len(tasks) > 0:\\n try:\\n # check if we have time\\n timekeeper.ping()\\n\\n if settings.GCI_TASK_QUOTA_LIMIT_ENABLED and task_quota <= 0:\\n return error_handler.logErrorAndReturnOK(\\n 'Task quota reached for %s' %(org_admin.scope.name))\\n\\n # remove the first task\\n task_as_string = tasks.pop(0)\\n\\n loaded_task = simplejson.loads(task_as_string)\\n task = {}\\n for key, value in loaded_task.iteritems():\\n # If we don't do this python will complain about kwargs not being\\n # strings when we try to save the new task.\\n task[key.encode('UTF-8')] = value\\n\\n logging.info('Uncleaned task: %s' %task)\\n # clean the data\\n errors = _cleanTask(task, org_admin)\\n\\n if errors:\\n logging.warning(\\n 'Invalid task data uploaded, the following errors occurred: %s'\\n %errors)\\n bulk_data.errors.append(db.Text(\\n 'The task in row %i contains the following errors.\\\\n %s' \\\\\\n %(bulk_data.tasksRemoved(), '\\\\n'.join(errors))))\\n\\n # at-most-once semantics for creating tasks\\n bulk_data.put()\\n\\n if errors:\\n # do the next task\\n continue\\n\\n # set other properties\\n task['link_id'] = 't%i' % (int(time.time()*100))\\n task['scope'] = org_admin.scope\\n task['scope_path'] = org_admin.scope_path\\n task['program'] = org_admin.program\\n task['status'] = 'Unpublished'\\n task['created_by'] = org_admin\\n task['modified_by'] = org_admin\\n\\n # create the new task\\n logging.info('Creating new task with fields: %s' %task)\\n task_logic.updateOrCreateFromFields(task)\\n task_quota = task_quota - 1\\n except DeadlineExceededError:\\n # time to bail out\\n pass\\n\\n if len(tasks) == 0:\\n # send out a message\\n notifications.sendBulkCreationCompleted(bulk_data)\\n bulk_data.delete()\\n else:\\n # there is still work to be done, do a non 500 response and requeue\\n task_params = {\\n 'bulk_create_key': bulk_data.key().id_or_name()\\n }\\n new_task = taskqueue.Task(params=task_params,\\n url=BULK_CREATE_URL)\\n # add to the gci queue\\n new_task.add(queue_name='gci-update')\\n\\n # we're done here\\n return http.HttpResponse('OK')\",\n \"def insert_mass(self, table_name, data, ignore=False):\\n fields = []\\n to_insert = []\\n for row in data:\\n if not len(fields):\\n fields = map((lambda s: \\\"`\\\" + str(s) + \\\"`\\\"), row.keys())\\n values = map(self.quote, row.values())\\n to_insert.append(\\\"({0})\\\".format(\\\", \\\".join(values)))\\n\\n if len(to_insert)%50 == 0:\\n self.q(\\n \\\"INSERT \\\" + (\\\"IGNORE\\\" if ignore else \\\"\\\") + \\\" INTO `{0}` ({1}) VALUES {2}\\\"\\n .format(table_name, \\\", \\\".join(fields), \\\", \\\".join(to_insert))\\n )\\n to_insert = []\\n\\n if len(to_insert):\\n self.q(\\n \\\"INSERT \\\" + (\\\"IGNORE\\\" if ignore else \\\"\\\") + \\\" INTO `{0}` ({1}) VALUES {2}\\\"\\n .format(table_name, \\\", \\\".join(fields), \\\", \\\".join(to_insert))\\n )\",\n \"def run_insert_example():\\n table = \\\"actors\\\"\\n insert_values = {\\n 'id': 3,\\n 'name': \\\"Matt\\\",\\n 'last_name': \\\"Smith\\\",\\n 'country': \\\"England\\\"}\\n print querify.insert_from_dict(table, insert_values)\\n\\n insert_col_list = [\\\"id\\\", \\\"name\\\", \\\"last_name\\\", \\\"country\\\"]\\n insert_val_list = [\\n [1, \\\"Chris\\\", \\\"Eccleston\\\", \\\"England\\\"],\\n [2, \\\"David\\\", \\\"Tennant\\\", \\\"Scotland\\\"],\\n [3, \\\"Matt\\\", \\\"Smith\\\", \\\"England\\\"]]\\n print querify.insert_from_list(table, insert_col_list, insert_val_list)\",\n \"def put(self,items,priority=0):\\n with self.pdq:\\n self.pdq.cursor().executemany('insert into pdq values (?,?)',[(item,priority) for item in self._toiter(items)])\",\n \"def insert_many(self, query: str, args):\\n cursor = self._cursor()\\n try:\\n cursor.execute_many(query, args)\\n return cursor.lastrowid\\n finally:\\n cursor.close()\",\n \"def test_bulk(self):\\n\\n class BlogPost(Document):\\n title = StringField()\\n\\n BlogPost.drop_collection()\\n\\n post_1 = BlogPost(title=\\\"Post #1\\\")\\n post_2 = BlogPost(title=\\\"Post #2\\\")\\n post_3 = BlogPost(title=\\\"Post #3\\\")\\n post_4 = BlogPost(title=\\\"Post #4\\\")\\n post_5 = BlogPost(title=\\\"Post #5\\\")\\n\\n post_1.save()\\n post_2.save()\\n post_3.save()\\n post_4.save()\\n post_5.save()\\n\\n ids = [post_1.id, post_2.id, post_5.id]\\n objects = BlogPost.objects.in_bulk(ids)\\n\\n assert len(objects) == 3\\n\\n assert post_1.id in objects\\n assert post_2.id in objects\\n assert post_5.id in objects\\n\\n assert objects[post_1.id].title == post_1.title\\n assert objects[post_2.id].title == post_2.title\\n assert objects[post_5.id].title == post_5.title\\n\\n objects = BlogPost.objects.as_pymongo().in_bulk(ids)\\n assert len(objects) == 3\\n assert isinstance(objects[post_1.id], dict)\\n\\n BlogPost.drop_collection()\",\n \"def bulk_index_records(records):\\n indexer = RecordIndexer()\\n\\n click.echo('Bulk indexing {} records...'.format(len(records)))\\n indexer.bulk_index([str(r.id) for r in records])\\n indexer.process_bulk_queue()\\n click.echo('Indexing completed!')\",\n \"def insert_to_elastic(elastic, paper_authors, papers, authors, index_name):\\n helpers.bulk(elastic, merge_to_elastic(paper_authors, papers, authors, index_name))\",\n \"def executeQuery(self, segments=None,):\\n if not segments: segments = self.segments\\n query =''.join(['INSERT INTO ', self.tableName, ' (',\\n ', '.join(self.firstLine), ') VALUES ',\\n ', '.join([segment for segment in segments]), ';'])\\n try:\\n self.cursorExecute(query)\\n except:\\n print 'Bulk query rejected, splitting into smaller queries.'\\n self.handleSQLRejection(0, len(self.segments))\",\n \"def to_db(self):\\n bulk = conn_db().initialize_ordered_bulk_op()\\n for fiction in self.fictions:\\n bulk.find({'id': fiction.id}).upsert().update({'$set': fiction.__dict__})\\n bulk.execute()\",\n \"def insert_data(data, collec, many):\\n db = client.get_database('tweetstorm')\\n collection = db.get_collection(collec)\\n if many:\\n collection.insert_many(data)\\n logger.info(f\\\"{ymdhms()} inserted {len(data)} tweets to {collec} collection\\\")\\n else:\\n collection.insert_one(data)\\n logger.info(f\\\"{ymdhms()} inserted data {data} to {collec} collection\\\")\",\n \"def bulk_upsert(self, docs, namespace, timestamp):\\n def docs_to_upsert():\\n doc = None\\n for doc in docs:\\n # Remove metadata and redundant _id\\n index, doc_type = self._index_and_mapping(namespace)\\n doc_id = u(doc.pop(\\\"_id\\\"))\\n document_action = {\\n '_index': index,\\n '_type': doc_type,\\n '_id': doc_id,\\n '_source': self._formatter.format_document(doc)\\n }\\n document_meta = {\\n '_index': self.meta_index_name,\\n '_type': self.meta_type,\\n '_id': doc_id,\\n '_source': {\\n 'ns': namespace,\\n '_ts': timestamp\\n }\\n }\\n yield document_action\\n yield document_meta\\n if doc is None:\\n raise errors.EmptyDocsError(\\n \\\"Cannot upsert an empty sequence of \\\"\\n \\\"documents into Elastic Search\\\")\\n try:\\n kw = {}\\n if self.chunk_size > 0:\\n kw['chunk_size'] = self.chunk_size\\n\\n responses = streaming_bulk(client=self.elastic,\\n actions=docs_to_upsert(),\\n **kw)\\n\\n for ok, resp in responses:\\n if not ok:\\n LOG.error(\\n \\\"Could not bulk-upsert document \\\"\\n \\\"into ElasticSearch: %r\\\" % resp)\\n if self.auto_commit_interval == 0:\\n self.commit()\\n except errors.EmptyDocsError:\\n # This can happen when mongo-connector starts up, there is no\\n # config file, but nothing to dump\\n pass\",\n \"def insert_into_sql(chunk):\\n bulk_list = []\\n for row in chunk:\\n bulk_list.append(StockData(\\n date=str(row[0])[0:4] + '-' + str(row[0])[4:6] + '-' + str(row[0])[6:8],\\n code=row[1],\\n code_name=row[2],\\n d1_diff_rate=row[3],\\n close=row[4],\\n open=row[5],\\n high=row[6],\\n low=row[7],\\n volume=row[8],\\n clo5=row[9],\\n clo10=row[10],\\n clo20=row[11],\\n clo40=row[12],\\n clo60=row[13],\\n clo80=row[14],\\n clo100=row[15],\\n clo120=row[16],\\n clo5_diff_rate=row[17],\\n clo10_diff_rate=row[18],\\n clo20_diff_rate=row[19],\\n clo40_diff_rate=row[20],\\n clo60_diff_rate=row[21],\\n clo80_diff_rate=row[22],\\n clo100_diff_rate=row[23],\\n clo120_diff_rate=row[24],\\n yes_clo_5=row[25],\\n yes_clo_10=row[26],\\n yes_clo_20=row[27],\\n yes_clo_40=row[28],\\n yes_clo_60=row[29],\\n yes_clo_80=row[30],\\n yes_clo_100=row[31],\\n yes_clo_120=row[32],\\n vol5=row[33],\\n vol10=row[34],\\n vol20=row[35],\\n vol40=row[36],\\n vol60=row[37],\\n vol80=row[38],\\n vol100=row[39],\\n vol120=row[40],\\n ))\\n StockData.objects.bulk_create(bulk_list)\\n return bulk_list\",\n \"def bulk_upsert(self, data, parameters=None, many_to_many_clear: bool = True):\\n elements = []\\n\\n # Skip if no identifier is set\\n if not self.unique_identifier or not data:\\n return\\n\\n for element in data:\\n if isinstance(parameters, dict):\\n element.update(parameters)\\n\\n element, created = self.upsert(data=element, many_to_many_clear=many_to_many_clear)\\n elements.append(element)\\n\\n return elements\",\n \"def execute(self):\\n for coll in list(self.__bulks):\\n try:\\n bulkOp = self.__bulks[coll]\\n curr_result = Counter(bulkOp.execute())\\n self.update_results(coll, curr_result)\\n except BulkWriteError as bwe:\\n sys.stderr.write(str(bwe.details))\",\n \"def bulkSave(self, objList: List[PermissionContext], tokenData: TokenData):\",\n \"def bulk_create(\\n self,\\n objs,\\n batch_size=None,\\n ignore_conflicts=False,\\n update_conflicts=False,\\n update_fields=None,\\n unique_fields=None,\\n ):\\n # When you bulk insert you don't get the primary keys back (if it's an\\n # autoincrement, except if can_return_rows_from_bulk_insert=True), so\\n # you can't insert into the child tables which references this. There\\n # are two workarounds:\\n # 1) This could be implemented if you didn't have an autoincrement pk\\n # 2) You could do it by doing O(n) normal inserts into the parent\\n # tables to get the primary keys back and then doing a single bulk\\n # insert into the childmost table.\\n # We currently set the primary keys on the objects when using\\n # PostgreSQL via the RETURNING ID clause. It should be possible for\\n # Oracle as well, but the semantics for extracting the primary keys is\\n # trickier so it's not done yet.\\n if batch_size is not None and batch_size <= 0:\\n raise ValueError(\\\"Batch size must be a positive integer.\\\")\\n # Check that the parents share the same concrete model with the our\\n # model to detect the inheritance pattern ConcreteGrandParent ->\\n # MultiTableParent -> ProxyChild. Simply checking self.model._meta.proxy\\n # would not identify that case as involving multiple tables.\\n for parent in self.model._meta.get_parent_list():\\n if parent._meta.concrete_model is not self.model._meta.concrete_model:\\n raise ValueError(\\\"Can't bulk create a multi-table inherited model\\\")\\n if not objs:\\n return objs\\n opts = self.model._meta\\n if unique_fields:\\n # Primary key is allowed in unique_fields.\\n unique_fields = [\\n self.model._meta.get_field(opts.pk.name if name == \\\"pk\\\" else name)\\n for name in unique_fields\\n ]\\n if update_fields:\\n update_fields = [self.model._meta.get_field(name) for name in update_fields]\\n on_conflict = self._check_bulk_create_options(\\n ignore_conflicts,\\n update_conflicts,\\n update_fields,\\n unique_fields,\\n )\\n self._for_write = True\\n fields = opts.concrete_fields\\n objs = list(objs)\\n self._prepare_for_bulk_create(objs)\\n with transaction.atomic(using=self.db, savepoint=False):\\n objs_with_pk, objs_without_pk = partition(lambda o: o.pk is None, objs)\\n if objs_with_pk:\\n returned_columns = self._batched_insert(\\n objs_with_pk,\\n fields,\\n batch_size,\\n on_conflict=on_conflict,\\n update_fields=update_fields,\\n unique_fields=unique_fields,\\n )\\n for obj_with_pk, results in zip(objs_with_pk, returned_columns):\\n for result, field in zip(results, opts.db_returning_fields):\\n if field != opts.pk:\\n setattr(obj_with_pk, field.attname, result)\\n for obj_with_pk in objs_with_pk:\\n obj_with_pk._state.adding = False\\n obj_with_pk._state.db = self.db\\n if objs_without_pk:\\n fields = [f for f in fields if not isinstance(f, AutoField)]\\n returned_columns = self._batched_insert(\\n objs_without_pk,\\n fields,\\n batch_size,\\n on_conflict=on_conflict,\\n update_fields=update_fields,\\n unique_fields=unique_fields,\\n )\\n connection = connections[self.db]\\n if (\\n connection.features.can_return_rows_from_bulk_insert\\n and on_conflict is None\\n ):\\n assert len(returned_columns) == len(objs_without_pk)\\n for obj_without_pk, results in zip(objs_without_pk, returned_columns):\\n for result, field in zip(results, opts.db_returning_fields):\\n setattr(obj_without_pk, field.attname, result)\\n obj_without_pk._state.adding = False\\n obj_without_pk._state.db = self.db\\n\\n return objs\",\n \"def multiple_insertion(self, insert_lists):\\n for args in insert_lists:\\n self.Log.execute(\\n \\\" \\\".join(\\n [\\n \\\"INSERT IGNORE INTO {} ({})\\\".format(*args),\\n self.build_params_values(args[-1]),\\n ]\\n ),\\n args[-1],\\n )\",\n \"def bulk_process(self):\\n\\n def actions():\\n try:\\n task = self.queue.get(block=False, timeout=None)\\n\\n if task['action'] == 'index':\\n yield {\\n '_op_type': 'index',\\n '_index': self.ensure_index(task),\\n '_id': task['id'],\\n 'doc': task['properties']\\n }\\n elif task['action'] == 'delete':\\n yield {\\n '_op_type': 'delete',\\n '_index': self.ensure_index(task),\\n '_id': task['id'],\\n 'doc': task['properties']\\n }\\n else:\\n raise NotImplementedError\\n\\n except Empty:\\n pass\\n\\n for success, info in streaming_bulk(self.es_client, actions()):\\n if success:\\n self.queue.task_done()\",\n \"def test_core_insert(n):\\n with engine.begin() as conn:\\n conn.execute(\\n Customer.__table__.insert(),\\n [\\n dict(\\n name=\\\"customer name %d\\\" % i,\\n description=\\\"customer description %d\\\" % i,\\n )\\n for i in range(n)\\n ],\\n )\",\n \"def bulk_push_to_elastic(elastic_search_url, index, docs):\\n CREATE_TEMPLATE = {\\\"create\\\": {\\\"_index\\\": index, \\\"_type\\\": \\\"_doc\\\", \\\"_id\\\": \\\"\\\"}}\\n\\n bulk_request_body = \\\"\\\"\\n for doc in docs:\\n CREATE_TEMPLATE[\\\"create\\\"][\\\"_id\\\"] = doc[HASH_ID]\\n bulk_request_body += json.dumps(CREATE_TEMPLATE) + NEW_LINE\\n bulk_request_body += json.dumps(doc) + NEW_LINE\\n\\n # Request\\n headers = {\\\"content-type\\\": \\\"application/x-ndjson\\\"}\\n\\n url = elastic_search_url + \\\"/\\\" + \\\"_bulk\\\"\\n\\n response = requests.post(url, data=bulk_request_body, headers=headers)\\n return response\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7786845","0.77852196","0.7621423","0.7350911","0.73435855","0.7124371","0.7046553","0.7034076","0.6918839","0.68964547","0.6739422","0.67058235","0.6680829","0.66706884","0.6661056","0.66548723","0.6608459","0.6563865","0.6560858","0.6558214","0.65197206","0.64988875","0.64859974","0.6473654","0.64610845","0.6441633","0.6390915","0.63732594","0.63711727","0.6358487","0.63570744","0.63528556","0.63274264","0.63031846","0.6289694","0.62769216","0.62454176","0.62404376","0.62305754","0.62059677","0.6190864","0.6163606","0.6163101","0.6122604","0.61211807","0.60822034","0.6079798","0.6077018","0.605731","0.60559565","0.6051287","0.60505545","0.6047603","0.6042433","0.6024864","0.6008815","0.5975741","0.5971026","0.5961024","0.59506094","0.59272826","0.592726","0.5908555","0.58946306","0.58886844","0.5888388","0.58870804","0.58843946","0.587795","0.5875757","0.584504","0.5839191","0.5830001","0.5829882","0.58264244","0.58136326","0.58031946","0.58025354","0.5799244","0.57885444","0.57872546","0.57857907","0.57828504","0.5778555","0.57733303","0.57716113","0.57697177","0.576827","0.5747483","0.57456994","0.5739933","0.5737354","0.5735454","0.5728737","0.5717513","0.5708402","0.5698119","0.56820744","0.56784004","0.5673692","0.56706464"],"string":"[\n \"0.7786845\",\n \"0.77852196\",\n \"0.7621423\",\n \"0.7350911\",\n \"0.73435855\",\n \"0.7124371\",\n \"0.7046553\",\n \"0.7034076\",\n \"0.6918839\",\n \"0.68964547\",\n \"0.6739422\",\n \"0.67058235\",\n \"0.6680829\",\n \"0.66706884\",\n \"0.6661056\",\n \"0.66548723\",\n \"0.6608459\",\n \"0.6563865\",\n \"0.6560858\",\n \"0.6558214\",\n \"0.65197206\",\n \"0.64988875\",\n \"0.64859974\",\n \"0.6473654\",\n \"0.64610845\",\n \"0.6441633\",\n \"0.6390915\",\n \"0.63732594\",\n \"0.63711727\",\n \"0.6358487\",\n \"0.63570744\",\n \"0.63528556\",\n \"0.63274264\",\n \"0.63031846\",\n \"0.6289694\",\n \"0.62769216\",\n \"0.62454176\",\n \"0.62404376\",\n \"0.62305754\",\n \"0.62059677\",\n \"0.6190864\",\n \"0.6163606\",\n \"0.6163101\",\n \"0.6122604\",\n \"0.61211807\",\n \"0.60822034\",\n \"0.6079798\",\n \"0.6077018\",\n \"0.605731\",\n \"0.60559565\",\n \"0.6051287\",\n \"0.60505545\",\n \"0.6047603\",\n \"0.6042433\",\n \"0.6024864\",\n \"0.6008815\",\n \"0.5975741\",\n \"0.5971026\",\n \"0.5961024\",\n \"0.59506094\",\n \"0.59272826\",\n \"0.592726\",\n \"0.5908555\",\n \"0.58946306\",\n \"0.58886844\",\n \"0.5888388\",\n \"0.58870804\",\n \"0.58843946\",\n \"0.587795\",\n \"0.5875757\",\n \"0.584504\",\n \"0.5839191\",\n \"0.5830001\",\n \"0.5829882\",\n \"0.58264244\",\n \"0.58136326\",\n \"0.58031946\",\n \"0.58025354\",\n \"0.5799244\",\n \"0.57885444\",\n \"0.57872546\",\n \"0.57857907\",\n \"0.57828504\",\n \"0.5778555\",\n \"0.57733303\",\n \"0.57716113\",\n \"0.57697177\",\n \"0.576827\",\n \"0.5747483\",\n \"0.57456994\",\n \"0.5739933\",\n \"0.5737354\",\n \"0.5735454\",\n \"0.5728737\",\n \"0.5717513\",\n \"0.5708402\",\n \"0.5698119\",\n \"0.56820744\",\n \"0.56784004\",\n \"0.5673692\",\n \"0.56706464\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":201,"numItemsPerPage":100,"numTotalItems":95772,"offset":20100,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjMzMzIxNSwianRpIjoiMTU2OTgxNmUtMDE5ZC00ZTYyLTlhYzctNTY3NWU3Yzk2NzNkIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYzMzY4MTUsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.aMi0Yx3cWirpdxztAGTtdPYIgUOFzfZHyyBAHXjjz2mM3iDl1Ck8iqaAp4JL3REcEUSgz9wialBEm7A2X1-BCA","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Construct from a string. | def __init__(self, url):
self.scheme, self.netloc, self.path, self.params, self.query, self.fragment = urlparse.urlparse(url)
self.args = dict(cgi.parse_qsl(self.query)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def from_str(cls, string):",
"def from_string(cls, string):\n normalised = cls.normalise_string(string)\n return cls.from_normalised_string(normalised)",
"def from_str(cls, s):\n raise NotImplementedError",
"def fromString(cls, string):\n raise NotImplementedError(\n 'f... | [
"0.85356504",
"0.81620204",
"0.80366236",
"0.7843013",
"0.75405395",
"0.7214952",
"0.71933556",
"0.71382374",
"0.70977336",
"0.708849",
"0.70854414",
"0.69782305",
"0.6877925",
"0.6861888",
"0.68387073",
"0.68277013",
"0.6827524",
"0.68031204",
"0.67619115",
"0.6694249",
"0.6... | 0.0 | -1 |
Turn back into a URL. | def __str__(self):
self.query = urllib.urlencode(self.args)
self.query = urllib.unquote(self.query)
return urlparse.urlunparse((self.scheme, self.netloc, self.path, self.params, self.query, self.fragment)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_url(self):\n ...",
"def _get_url(self, absolute):",
"def getURLForThing(thing):",
"def url_python(name):\n\n return reverse(name)",
"def make_linkback_url(self, entity_id, linkback_url=LINKBACK_URL):\n return urljoin(self.reaqta_url, linkback_url.format(entity_id))",
"def encod... | [
"0.7465716",
"0.67603785",
"0.66695213",
"0.6654594",
"0.6653037",
"0.6630416",
"0.66212803",
"0.6593365",
"0.65877587",
"0.6565282",
"0.65167004",
"0.6515478",
"0.65044045",
"0.63881636",
"0.63784254",
"0.6364418",
"0.6336821",
"0.6325689",
"0.62948734",
"0.6294366",
"0.6294... | 0.0 | -1 |
Safe conversion of page to utf | def __init__(self, page):
try:
self.page = page.encode("utf8")
except UnicodeDecodeError:
self.page = page.decode('iso-8859-1').encode('utf8') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convertFromUnicode(content):\n return content",
"def process_page(page):\n content = utils.any2unicode(page, 'utf8').strip()\n content = re.sub(r\"[^a-zA-Z]\", \" \", content)\n \n return content",
"def fix_unicode_encode_error(cls, safe=False):\n from .path9 import Path\n from... | [
"0.65442806",
"0.6308765",
"0.62095857",
"0.6024676",
"0.59617436",
"0.5852157",
"0.58336884",
"0.5832144",
"0.5830336",
"0.5777034",
"0.5749223",
"0.5742238",
"0.5740002",
"0.57341146",
"0.57124454",
"0.56925076",
"0.5677184",
"0.5604121",
"0.5572304",
"0.5555498",
"0.555383... | 0.64852524 | 1 |
Convert page to str | def __str__(self):
return str(self.page) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def page_to_string(page, alph):\n s = ''\n links = Measurements.get_all_links(page)\n for l in links:\n s += alph[l]\n return s",
"def process_page(page):\n content = utils.any2unicode(page, 'utf8').strip()\n content = re.sub(r\"[^a-zA-Z]\", \" \", content)\n \n ... | [
"0.72416747",
"0.6311964",
"0.61297363",
"0.61254025",
"0.6117378",
"0.6117378",
"0.5759532",
"0.5716281",
"0.5664423",
"0.5635445",
"0.5631912",
"0.5611601",
"0.55995196",
"0.5591691",
"0.5526723",
"0.551222",
"0.5453172",
"0.5440903",
"0.5410642",
"0.54025006",
"0.5399925",... | 0.68699765 | 1 |
Read the table with a TextField but not using it | def handle(self, *args, **options):
fname = sys.argv[-1:][0]
with open(fname, 'rb') as csvfile:
spamreader = csv.reader(csvfile, delimiter=',')
for row in spamreader:
OsmUser.objects.get_or_create(osm_uid=row[0],
user... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read(self, reader, font, tableDict):\n raise NotImplementedError(self)",
"def read_table(self, table):\n return READ_TABLE(table, db=self.db)",
"def read_table_data(self, table):\n data = []\n index = 0\n for row in table.rows:\n data.append([])\n fo... | [
"0.62954724",
"0.62869",
"0.5819639",
"0.5769961",
"0.5718858",
"0.5705405",
"0.56715155",
"0.55771077",
"0.54952884",
"0.54704595",
"0.5406692",
"0.5393933",
"0.53732544",
"0.53460866",
"0.53425133",
"0.53248733",
"0.53228766",
"0.5319017",
"0.53152037",
"0.52845067",
"0.528... | 0.0 | -1 |
Create the association rules | def generateRules(L, support_data, min_confidence=0.5):
rules = []
for i in range(1, len(L)):
for freqSet in L[i]:
H1 = [frozenset([item]) for item in freqSet]
if (i > 1):
rules_from_conseq(freqSet, H1, support_data, rules, min_confidence)
else:... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generateAssociationRule(freqSet):",
"def _populate_rules(self,rules):\n rule2_index = {}\n for rule in rules:\n relation = rule.get_attribute('relation')[0] # vals are now lists\n ##: Time signals of IS_INCLUDED should not be used in relative time evaluation. They may cau... | [
"0.7194264",
"0.64298874",
"0.62917304",
"0.6201002",
"0.6114039",
"0.6044059",
"0.5934298",
"0.58875114",
"0.58138055",
"0.5782265",
"0.57409334",
"0.57329404",
"0.5725848",
"0.5725742",
"0.56868804",
"0.5658817",
"0.5649701",
"0.560628",
"0.5596754",
"0.5576119",
"0.5553087... | 0.0 | -1 |
Returns the type of applying the binary operator with the current type and the type of the right operand, or returns None if the operation is not valid | def binop_type(cls, op, right_type):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def evaluate_operation(\n statement: ast.BinOp,\n) -> Optional[Union[int, float, str, bytes]]:\n if isinstance(statement.left, ast.BinOp):\n left = evaluate_operation(statement.left)\n else:\n left = evaluate_node(statement.left)\n\n if isinstance(statement.right, ast.BinOp):\n rig... | [
"0.6980014",
"0.6376216",
"0.63047373",
"0.6289566",
"0.6168144",
"0.5986405",
"0.594299",
"0.5919433",
"0.59048015",
"0.58846456",
"0.58320713",
"0.5771884",
"0.5764865",
"0.5709627",
"0.57065237",
"0.56597155",
"0.5610864",
"0.5607209",
"0.55886",
"0.5584397",
"0.5579483",
... | 0.7616685 | 0 |
Returns the type of applying the unary operator to the current type | def unaryop_type(cls, op):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unary_operator(op):\n # Only negate is currently supported for all our possible input types.\n valid_ops = {'-'}\n if op not in valid_ops:\n raise ValueError(\"Invalid unary operator %s.\" % op)\n\n def unary_operator(self):\n # This can't be hoisted up a scope because the types retur... | [
"0.7026326",
"0.62878203",
"0.62745595",
"0.6230687",
"0.61832154",
"0.6153777",
"0.6153615",
"0.6035553",
"0.60099876",
"0.5954016",
"0.59390163",
"0.5836451",
"0.58051866",
"0.5675768",
"0.56312513",
"0.55480313",
"0.55199814",
"0.5483337",
"0.54803765",
"0.5456091",
"0.539... | 0.73739296 | 0 |
Ensure that pytest's config.option.verbose is <= 0. | def nonverbose_config(config) -> Generator[None, None, None]:
if config.option.verbose <= 0:
yield
else:
saved = config.option.verbose
config.option.verbose = 0
yield
config.option.verbose = saved | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_valid_verbose(verbose: Any) -> None:\n check_verbose(verbose)",
"def test_verbose_non_bool_error(self):\n\n with pytest.raises(ValueError):\n\n BaseTransformer(verbose=1)",
"def test_invalid_verbose(verbose: Any) -> None:\n with pytest.raises(ValueError, match=r\".*Invalid verb... | [
"0.72909325",
"0.7116359",
"0.69435227",
"0.67122096",
"0.6585893",
"0.65532297",
"0.65245336",
"0.6418826",
"0.62999177",
"0.62315834",
"0.62073755",
"0.6173831",
"0.6169409",
"0.61526793",
"0.6150769",
"0.6149129",
"0.6140586",
"0.61110395",
"0.6096457",
"0.6042438",
"0.604... | 0.66538364 | 4 |
Ensure that settings are restored after test_settings_before. | def test_settings_restored(self) -> None:
from django.conf import settings
assert TestLiveServer._test_settings_before_run is True # type: ignore[attr-defined]
assert (
f"{settings.__class__.__module__}.{settings.__class__.__name__}"
== "django.conf.Settings"
)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def teardown_function():\n\n # Force module reload as the default test settings have been restored\n importlib.reload(defaults)",
"def teardown_method(self, method):\n restore_settings()",
"def teardown(self):\n # dump persistent storage to file\n dump_persistent_settings(self.settin... | [
"0.73878825",
"0.6784818",
"0.6733559",
"0.6715742",
"0.6488583",
"0.6481755",
"0.6481755",
"0.64424235",
"0.64274263",
"0.6407588",
"0.6295553",
"0.6175864",
"0.61559063",
"0.61030084",
"0.609804",
"0.6097769",
"0.60595536",
"0.60365754",
"0.6018529",
"0.60083866",
"0.598593... | 0.775121 | 0 |
LiveServer always serves statics with ``django.contrib.staticfiles`` handler. | def test_serve_static_with_staticfiles_app(self, django_testdir, settings) -> None:
django_testdir.create_test_module(
"""
from urllib.request import urlopen
from django.utils.encoding import force_str
class TestLiveServer:
def test_a(self, live_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def serve_static_files(request, path, insecure=False, **kwargs):\n\n if not settings.DEBUG and not insecure:\n raise Http404\n normalized_path = posixpath.normpath(unquote(path)).lstrip('/')\n absolute_path = finders.find(normalized_path)\n if not absolute_path:\n if path.endswith('/') or... | [
"0.692166",
"0.6793395",
"0.672456",
"0.66780925",
"0.6508464",
"0.6489936",
"0.646022",
"0.6422593",
"0.6398329",
"0.6394773",
"0.6379119",
"0.6352794",
"0.63344926",
"0.6232494",
"0.6215064",
"0.6189717",
"0.61667037",
"0.6146262",
"0.61179745",
"0.6043764",
"0.60087985",
... | 0.70656496 | 0 |
Because ``django.contrib.staticfiles`` is not installed LiveServer can not serve statics with django >= 1.7 . | def test_serve_static_dj17_without_staticfiles_app(self, live_server, settings) -> None:
with pytest.raises(HTTPError):
urlopen(live_server + "/static/a_file.txt").read() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_serve_static_with_staticfiles_app(self, django_testdir, settings) -> None:\n django_testdir.create_test_module(\n \"\"\"\n from urllib.request import urlopen\n\n from django.utils.encoding import force_str\n\n class TestLiveServer:\n def te... | [
"0.6716268",
"0.6231927",
"0.6190265",
"0.61497104",
"0.592605",
"0.59110135",
"0.58870727",
"0.5886149",
"0.5850551",
"0.5821276",
"0.5779303",
"0.5771501",
"0.57279146",
"0.57038695",
"0.56011933",
"0.5590249",
"0.55280924",
"0.5513304",
"0.5501698",
"0.5489761",
"0.5481401... | 0.6403566 | 1 |
TextResponse will be not applied by RuleExtractor. Need convert to HtmlResponse | def process_response(request, response, spider):
headers = ['text/html; charset=UTF-8', 'text/html; charset=utf-8', 'text/html;charset=UTF-8',
'text/html;charset=utf-8', 'text/html;charset=ISO-8859-1',
'application/xhtml+xml; charset=utf-8']
# log.msg("In Midd... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_html_output(self):\n pass",
"def get_html(self):\r\n pass",
"def _format_response(self, response):\n texts = []\n for result in response.results: \n texts.append(result.alternatives[0].transcript)\n return texts",
"def process_response(self, request, res... | [
"0.61386234",
"0.59616053",
"0.5953273",
"0.5924247",
"0.5882797",
"0.5802751",
"0.57943356",
"0.5772422",
"0.5726808",
"0.5726808",
"0.5669942",
"0.56435025",
"0.5613142",
"0.55854046",
"0.5585026",
"0.5578091",
"0.55673695",
"0.55666703",
"0.5552076",
"0.553761",
"0.5524938... | 0.65883505 | 0 |
Authenticates and logs in a user to the site using the username and password in POST. | def auth_user(request):
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
if user.is_active:
login(request, user)
url_redirect = reverse('profile:profile', kwargs={'pk': ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n args = login_parser.parse_args()\n if request.form:\n username = request.form['username']\n password = request.form['password']\n else:\n username = args['username'] # form['username']\n password = args['password'] # form['password'... | [
"0.80378044",
"0.7825943",
"0.7822236",
"0.78152466",
"0.77747136",
"0.7735378",
"0.772263",
"0.7710776",
"0.76991826",
"0.7623518",
"0.76190025",
"0.75116575",
"0.7507971",
"0.7465829",
"0.74558264",
"0.74076825",
"0.73826706",
"0.73760235",
"0.7357261",
"0.73495364",
"0.733... | 0.0 | -1 |
Tests a given component dataframe for convergence, returning True for converged components | def test_component(self, component_dataframe, ignore_weight=False):
# define our acceptable bounds
skew_range = [-0.6, 0.6]
kurt_range = [-1.5, 0.75] # accept shorter tails for bang-on data
weight_low = 0.008
# perform weight test first if not ignored
if not ignore_wei... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def converged(self) -> bool:",
"def converged(self) -> bool:",
"def converged(self) -> bool:",
"def has_convergence_delta(self) -> bool:\n return False",
"def converged(self) -> bool:\n if self._species is not None and self._species.n_atoms == 1:\n return True # Optimisation 0 DOF... | [
"0.6538666",
"0.6538666",
"0.6538666",
"0.6366643",
"0.6296365",
"0.605637",
"0.58805627",
"0.58160526",
"0.57632166",
"0.5750119",
"0.5745037",
"0.57065284",
"0.5695569",
"0.5663899",
"0.56550163",
"0.5587026",
"0.55850583",
"0.5548356",
"0.553449",
"0.5469594",
"0.5452946",... | 0.6763347 | 0 |
Return a copy of the dynamics estimate. | def copy(self):
dyn = type(self)(self._hyperparams)
dyn.Fm = np.copy(self.Fm)
dyn.fv = np.copy(self.fv)
dyn.dyn_covar = np.copy(self.dyn_covar)
return dyn | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n return MultivariateDerivative(self.variables.copy())",
"def get_estimate(self) -> np.ndarray:\n return self.fit_function(self.x, self.coefficients)",
"def estimate(self) -> None:\n pass",
"def derivative ( self ):\n return self.__derivative",
"def copy(self):\n... | [
"0.65137255",
"0.62424964",
"0.61908615",
"0.59357244",
"0.5865188",
"0.58616906",
"0.58283806",
"0.57059515",
"0.5626296",
"0.562039",
"0.56190413",
"0.56190413",
"0.56011146",
"0.5548338",
"0.5543138",
"0.5528686",
"0.54649377",
"0.54125106",
"0.5405548",
"0.540251",
"0.539... | 0.5863494 | 6 |
Copy source file to target, do SWA edits, then add BUILD time stamp. | def GenerateSwaMainHtml(source, target):
# Copy source (main.html) file to the target (main.html) file.
shutil.copyfile(source, target)
# Edit the target file.
for line in fileinput.input(target, inplace=True):
# Add _SWA <script> tag after the <head> tag.
if line.find('<head>') >= 0:
print(line... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy_script(self):\n copy_source = self.script_file\n copy_dest = os.path.join(self.build_dir, os.path.basename(self.script_file))\n\n logging.debug('Copying {src} to {dst}..'.format(src=copy_source, dst=copy_dest))\n\n shutil.copyfile(\n src=copy_sour... | [
"0.61420363",
"0.5990112",
"0.58942825",
"0.57998633",
"0.57883006",
"0.5784454",
"0.57043713",
"0.56820434",
"0.5580893",
"0.55276066",
"0.5526816",
"0.5500946",
"0.54975355",
"0.54962784",
"0.5444876",
"0.5443569",
"0.5413264",
"0.5413264",
"0.5413264",
"0.54041624",
"0.540... | 0.57934564 | 4 |
Take location (code2,code3,country name) return countryName and coords | def locate(location):
coord = None
country_name = None
if location:
location = location.lower()
for ind, row in country_map.iterrows():
if (
(re.match(r'(.*\W|\W*){}\b'.format(row['code2']), location))
or(re.match(r'(.*\W|\W*){}\b'.format(row['code3']), location... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loc_to_coord(codes):\n def adfilter(codes):\n return re.findall(\"\"\"[a-zA-Z]+, [A-Z]{2}\"\"\", \";\".join(codes))\n\n api_key = \"AIzaSyCxQCjOrHFAf7T-W3vtUYqWkgSFkvMjxN4\"\n\n g = geocoders.GoogleV3(api_key = api_key)\n coords = {\"lat\":[], \"long\":[]}\n for code in adfilter(codes):\n... | [
"0.6872996",
"0.6658761",
"0.6427587",
"0.64248663",
"0.6413235",
"0.6389267",
"0.6352416",
"0.6344214",
"0.6342886",
"0.6201723",
"0.61685705",
"0.61586225",
"0.614145",
"0.61208564",
"0.6072315",
"0.606234",
"0.6036042",
"0.6028122",
"0.6024029",
"0.60227036",
"0.6012603",
... | 0.7792582 | 0 |
Read the steering file to gather user inputs from the GUI of pyRiverBed. Parameters are declared as global variables. | def read_steering():
print('+> Trying to read steering file...', end='')
try:
d = np.loadtxt('steering.txt', delimiter=',', skiprows=1)
print(' [done]')
except IOError:
print('\nNo steering file found')
print('Please provide steering file first\n')
job_done()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_input(self):\n try:\n path = tkFileDialog.askdirectory()\n if not path: # User the cancelled dialog box so bug out\n return False\n # Search the user-provided path for all the input files.\n foundall, missing = self.files.locate_input(path)... | [
"0.6534614",
"0.6480986",
"0.6264293",
"0.61416334",
"0.6109954",
"0.5936167",
"0.5849614",
"0.5842282",
"0.5826436",
"0.578414",
"0.57564574",
"0.57386065",
"0.5683754",
"0.567388",
"0.5645699",
"0.5645465",
"0.5632296",
"0.56240624",
"0.56231207",
"0.55820847",
"0.5581234",... | 0.68253434 | 0 |
Print a table displaying parameters read from the steering file. Require 'tabulate' library. | def print_para_table(s):
if MODE == 1:
t = [['Parameter', 'Value', 'Unit'],
['Number of bends', NBENDS, '/'],
['Width', WIDTH, 'm'],
['Depth', DEPTH, 'm'],
['Length', LAMBDA*(NBENDS+1), 'm'],
['Arc wavelength', LAMBDA, 'm'],
['Sl... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tab_printer(args):\n args = vars(args)\n keys = sorted(args.keys())\n tab = Texttable()\n tab.add_rows([[\"Parameter\", \"Value\"]])\n tab.add_rows([[k.replace(\"_\", \" \").capitalize(), args[k]] for k in keys])\n print(tab.draw())",
"def tab_printer(args):\n args = vars(args)\n keys... | [
"0.6731898",
"0.6727638",
"0.6693523",
"0.66596514",
"0.66596514",
"0.64847577",
"0.6466909",
"0.63867766",
"0.6372735",
"0.63454986",
"0.6304587",
"0.629846",
"0.62803787",
"0.62803787",
"0.62415814",
"0.6233019",
"0.621662",
"0.6205308",
"0.61270964",
"0.6085865",
"0.608106... | 0.7408522 | 0 |
Print a table displaying mean, median and mode of centerline grid size before and after resampling. Require 'tabulate' library. | def print_resamp_table(mean1, median1, mode1, mean2, median2, mode2):
t = [['Streamwise\nresolution', 'Before '
+'After\nresampling --> resampling', '\nUnit'],
['Mean', str(mean1) + ' --> ' + str(mean2), 'm'],
['Median', str(median1) + ' --> ' + str(median2), 'm'],
['Mode', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def summarize_as_table(self):\n h = human_readable_size\n h_throughput = human_readable_throughput\n table = [\n ['Total Time (seconds)', '%.3f' % self.total_time,\n self.std_dev_total_time],\n ['Maximum Memory', h(self.max_memory), h(self.std_dev_max_memory)]... | [
"0.6565323",
"0.6138334",
"0.6114011",
"0.6073732",
"0.60654634",
"0.605878",
"0.60337764",
"0.60322475",
"0.60169584",
"0.6001512",
"0.59973735",
"0.5922056",
"0.58799005",
"0.58584213",
"0.58325213",
"0.58321124",
"0.5765773",
"0.5743075",
"0.572621",
"0.5705246",
"0.567230... | 0.7362937 | 0 |
Print Kinoshita Curve equation. Only work for Mode 1. | def print_eqn():
if sys.stdout.encoding.lower().startswith('utf'):
if JS != 0 and JF != 0:
print('Eqn: \u03B8=' + str(np.around(THETA0, decimals=6)) +
'*sin(2\u03C0s/' + str(np.around(LAMBDA, decimals=6)) +
')\n +' + str(np.around(THETA0**3, decimals=6)) ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_kinoshita():\n if MODE != 1:\n return [], [], [], [], []\n print('MODE 1: GENERATE KINOSHITA CURVE FROM EQUATION is selected')\n print('Kinoshita Curve parameters are read from steering file:')\n print_eqn()\n s = np.linspace(0, NBENDS*LAMBDA, int(NBENDS*LAMBDA/DS) + 1)\n print_p... | [
"0.6009057",
"0.59244484",
"0.57258797",
"0.5719299",
"0.5606414",
"0.5596424",
"0.5556299",
"0.55449724",
"0.5524112",
"0.5523874",
"0.55117285",
"0.5498666",
"0.5461777",
"0.5460435",
"0.5453134",
"0.5452214",
"0.53886247",
"0.5387569",
"0.53753626",
"0.53699505",
"0.536399... | 0.6549474 | 0 |
Build Kinoshita Curve (noncomputational part). Only work for Mode 1. | def build_kinoshita():
if MODE != 1:
return [], [], [], [], []
print('MODE 1: GENERATE KINOSHITA CURVE FROM EQUATION is selected')
print('Kinoshita Curve parameters are read from steering file:')
print_eqn()
s = np.linspace(0, NBENDS*LAMBDA, int(NBENDS*LAMBDA/DS) + 1)
print_para_table(s)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calc_k(self):\n\t\n\tself.k = -np.array([self.sth*self.cphi, self.sth*self.sphi, self.cth])\n\n\treturn",
"def createAnisotropicK(powerSpectrum,center,aniso):\n\n if aniso > 1.:\n anisoNew = 1. / aniso\n padDim = int( np.round( powerSpectrum.shape[0] / ( anisoNew ) ) )\n else:\n ... | [
"0.61084265",
"0.58661884",
"0.5722478",
"0.56312686",
"0.562919",
"0.55858815",
"0.558461",
"0.5543797",
"0.55313665",
"0.5458351",
"0.5447106",
"0.5440787",
"0.5429062",
"0.5335893",
"0.5293114",
"0.52813584",
"0.5255335",
"0.5196818",
"0.51894844",
"0.5181761",
"0.5176679"... | 0.73484176 | 0 |
Build Kinoshita Curve (computational part). Numba nopyton mode is on. Only work for Mode 1. | def compute_kinoshita(s):
length = int(NBENDS*LAMBDA/DS) + 1
x = np.zeros(length)
y = np.zeros(length)
cur = np.zeros(length+1)
theta = THETA0*np.sin(2*np.pi*s/LAMBDA) \
+ THETA0**3*(JS*np.cos(6*np.pi*s/LAMBDA) \
- JF*np.sin(6*np.pi*s/LAMBDA))
theta[np.abs(theta)<ZERO] = ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_kinoshita():\n if MODE != 1:\n return [], [], [], [], []\n print('MODE 1: GENERATE KINOSHITA CURVE FROM EQUATION is selected')\n print('Kinoshita Curve parameters are read from steering file:')\n print_eqn()\n s = np.linspace(0, NBENDS*LAMBDA, int(NBENDS*LAMBDA/DS) + 1)\n print_p... | [
"0.6981509",
"0.58476263",
"0.56384975",
"0.5578285",
"0.55455077",
"0.55335504",
"0.5531249",
"0.54656094",
"0.5413885",
"0.53875285",
"0.53695947",
"0.53582776",
"0.5350835",
"0.5343008",
"0.533532",
"0.5330708",
"0.5330406",
"0.5329246",
"0.5329064",
"0.53226274",
"0.53211... | 0.511144 | 43 |
Read river centerline coordinates from userprepared centerline file. Centerline is then resampled to prevent ununiform spacing. Only work for Mode 2. | def read_centerline(s, x, y, cur, theta):
if MODE == 2:
print('MODE 2: READ YOUR OWN RIVER CENTERLINE FROM FILE is selected')
try:
centerlinexy = np.loadtxt(FNAME)
except IOError:
print('\'' + FNAME + '\' not found')
print('Please place \'' + FNAME + '\' i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ds9_line(self, center_coordinates, width=20 ):\n for fn in self.images:\n print(fn)\n ff = pyfits.open(fn)\n w = wcs.WCS(ff[0].header)\n co = center_coordinates\n print(co.ra.deg, co.dec.deg )\n #pix = w.wcs_world2pix([co.ra], [co.dec], 0... | [
"0.5484611",
"0.54598975",
"0.541714",
"0.5410985",
"0.53711194",
"0.5348809",
"0.53283346",
"0.5277495",
"0.5272035",
"0.52507305",
"0.52339166",
"0.5203206",
"0.5176077",
"0.5174357",
"0.5174031",
"0.51609975",
"0.51548326",
"0.5138431",
"0.5123837",
"0.50979066",
"0.508635... | 0.74167114 | 0 |
Extend centerline to have straight channels at both ends. | def extend_centerline(s, x, y, cur, theta):
print('+> Extending centerline to have straight channels at both ends...', end='')
if MODE == 1:
extlength = LAMBDA/10
d = DS
elif MODE == 2:
extlength = WIDTH
d = INTERVAL
num = int(extlength/d)
coshead = (x[1... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def centerAxis():\n dislin.center()",
"def linecenter(l):\n return scale3(add(l[0],l[1]),0.5)",
"def centerline_to_polygon(\n centerline: np.ndarray, width_scaling_factor: float = 1.0, visualize: bool = False\n) -> np.ndarray:\n # eliminate duplicates\n _, inds = np.unique(centerline, axis=0, re... | [
"0.6367526",
"0.6277636",
"0.60933346",
"0.58676577",
"0.58125347",
"0.57696474",
"0.5726331",
"0.5680378",
"0.56134474",
"0.5567007",
"0.55354726",
"0.5523416",
"0.5488831",
"0.5460297",
"0.5416137",
"0.5398362",
"0.53754103",
"0.5371892",
"0.5368449",
"0.5356547",
"0.534115... | 0.7979626 | 0 |
Impose a phase lag to the curvature signal by replacing the local curvature with the upstreamwise moving averaged curvature. | def lag(s, cur, t):
if LAG == 0:
return cur
else:
if MODE == 1:
num = int(WIDTH*LAGSTR/DS)
elif MODE == 2:
num = int(WIDTH*LAGSTR/np.mean(np.diff(s)))
if np.mod(t, LPRINT) == 0:
print('+> Adding phase lag to local curvature...', end='')
cur = compu... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_baseline(self):\n\n print(\" \\t Apply Savitzky-Golay filter \\t %d\" %self.nwin)\n base_savgol = signal.savgol_filter(self.input, self.nwin, 1)\n self.input_nobase = self.input - base_savgol",
"def adjust_u(self):\r\n # compute the volume integrals of the x,y, and z compon... | [
"0.5069656",
"0.49511254",
"0.4938894",
"0.49136677",
"0.48906946",
"0.48032054",
"0.46865338",
"0.46588433",
"0.4652921",
"0.4643875",
"0.4641906",
"0.46012482",
"0.4595003",
"0.45939776",
"0.45844513",
"0.45730233",
"0.45540237",
"0.45404497",
"0.4538936",
"0.45381907",
"0.... | 0.49604023 | 1 |
Compute phase lag. Numba nopyton mode is on. | def compute_lag(cur, num):
length = cur.size
cur0 = np.copy(cur)
for i in range(2, length):
M = i if i < num else num
c = 0
for j in range(M):
c += (2/M-j*2/M/(M-1))*cur0[i-j]
cur[i] = c
return cur | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phase_shift(annuli,annulus):\n delta_t = viscous_timescale(annuli[annulus+1]) - viscous_timescale(annuli[annulus])\n return int(delta_t)",
"def phase_Jupiter_2(alpha):\n # inds = np.where(alpha > 180.)[0]\n # alpha[inds] = [180.]*len(inds)\n # assert np.all((1.0 - 1.507*(alpha/180.) - 0.363*(a... | [
"0.568884",
"0.5633076",
"0.558322",
"0.5543549",
"0.5504063",
"0.5492323",
"0.5485697",
"0.5387924",
"0.5384837",
"0.5380682",
"0.5380151",
"0.53639066",
"0.52793896",
"0.52783406",
"0.5265017",
"0.52533853",
"0.5246012",
"0.5243909",
"0.52438074",
"0.52425396",
"0.5214989",... | 0.5392978 | 7 |
Compute curvature using 'arctan2' method. | def tan2curv(s, x, y):
length = x.size
cur = np.zeros(length)
forw = np.zeros(length)
back = np.zeros(length)
for i in range(1, length-1):
forw[i] = np.arctan2(y[i+1]-y[i], x[i+1]-x[i])
back[i] = np.arctan2(y[i]-y[i-1], x[i]-x[i-1])
angle_atan2 = forw[i] - back[i]
cur... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def arccurv(x, y):\n curv = curvature(x, y)\n steps = np.sqrt(np.diff(x, axis=0)**2 + np.diff(y, axis=0)**2)[:-1]\n arc = np.cumsum(steps)\n return arc, curv",
"def arccurv_i(x, y, l=0):\n if l==0:\n l = len(x)\n interp_coords = ia.interparc(l, x, y)\n x_i = interp_coords[:,0]\n y_... | [
"0.6816503",
"0.6449396",
"0.61861104",
"0.6150632",
"0.60887814",
"0.5969641",
"0.59119236",
"0.5848616",
"0.5770604",
"0.5740051",
"0.56768745",
"0.5649155",
"0.5575538",
"0.5567511",
"0.5558377",
"0.5544352",
"0.5520114",
"0.5505947",
"0.54986966",
"0.5483227",
"0.5448365"... | 0.53391874 | 32 |
Compute curvature using 'law of cosine' method. | def coscurv(s, x, y):
length = x.size
cur = np.zeros(length)
for i in range(1, length-1):
a = np.array([x[i+1]-x[i], y[i+1]-y[i]])
b = np.array([x[i]-x[i-1], y[i]-y[i-1]])
c = np.array([1, 0])
flag = 1
if flag == 1 and a[1] < 0:
flag = -1
elif flag... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curvature(x, y):\n dalpha = np.pi/1000\n xd1 = np.gradient(x, 2)\n xd2 = np.gradient(xd1, 2)\n yd1 = np.gradient(y, 2)\n yd2 = np.gradient(yd1, 2)\n\n return np.abs(xd1*yd2 - yd1*xd2) / np.power(xd1**2 + yd1**2, 3.0/2.0)",
"def curvature(self):\n return self.circle().curvature(self.o... | [
"0.76586115",
"0.7557801",
"0.74021304",
"0.7344014",
"0.7253225",
"0.70292807",
"0.697398",
"0.6943343",
"0.68664813",
"0.6865032",
"0.6755068",
"0.66258067",
"0.6600955",
"0.65058094",
"0.6376265",
"0.6309172",
"0.62980443",
"0.62669426",
"0.6178336",
"0.6120311",
"0.606228... | 0.5981495 | 24 |
Compute curvature using 'triangle's circumscribed circle ' method. | def threeptscurv(x, y):
length = x.size
R = np.zeros(length)
cur = np.zeros(length)
for i in range(1, length-1):
a = np.sqrt((x[i+1]-x[i])**2 + (y[i+1]-y[i])**2)
b = np.sqrt((x[i+1]-x[i-1])**2 + (y[i+1]-y[i-1])**2)
c = np.sqrt((x[i]-x[i-1])**2 + (y[i]-y[i-1])**2)
p = (a+b... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def curvature(self):\n return self.circle().curvature(self.o, self.r, p = self.a)",
"def curvature(self, t):\n dx = self.dx(t)\n dy = self.dy(t)\n dxx = self.dxx(t)\n dyy = self.dyy(t)\n return np.abs(dx * dyy - dy * dxx) / np.power(dx * dx + dy * dy, 1.5)",
"def curva... | [
"0.7887616",
"0.7790393",
"0.74798626",
"0.7411039",
"0.7347205",
"0.7338861",
"0.72747785",
"0.7150064",
"0.69930804",
"0.697757",
"0.6951256",
"0.6819586",
"0.6756915",
"0.6693438",
"0.6556853",
"0.64711803",
"0.64556247",
"0.63826823",
"0.63458794",
"0.6335935",
"0.6330669... | 0.56674206 | 41 |
Build synthetic bed topography (noncomputational part). | def build_beck(cur, s, t):
if np.mod(t, LPRINT) == 0:
print('+> Calculating synthetic riverbed topography...', end='')
beck_bed = compute_beck(cur, s)
beck_bed[np.abs(beck_bed)<ZERO] = 0
if np.mod(t, LPRINT) == 0:
print(' [done]')
return beck_bed | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build(self):\n nk_table = self.nk_table\n # Check for even interaction\n neighbor = int(self.order / 2)\n if self.order % 2 == 0:\n pre_neighbor = neighbor - 1\n else:\n pre_neighbor = neighbor\n # Use NK table to build phenotypes\n phenoty... | [
"0.58953184",
"0.5699495",
"0.56461006",
"0.5644794",
"0.5598251",
"0.54474026",
"0.54360324",
"0.5419926",
"0.540777",
"0.5390797",
"0.5360608",
"0.5349371",
"0.5319972",
"0.5319779",
"0.53049564",
"0.52962375",
"0.52820504",
"0.526801",
"0.5259576",
"0.5209306",
"0.5208436"... | 0.52213037 | 19 |
Build synthetic bed topography using Beck1988 formula (computational part). Numba nopyton mode is on. | def compute_beck(cur, s):
halfwidth = WIDTH/2
A = 3.8*(1+halfwidth/6.96/DEPTH*np.exp(-6.96*DEPTH/halfwidth))
st = -A*DEPTH*cur*STCORR
length = cur.size
hc = np.ones(length)
for i in range(length):
if np.abs(st[i]) < ZERO:
st[i] = ZERO
hc[i] = (4*halfwidth*DEPTH*np.abs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_beck(cur, s, t):\n if np.mod(t, LPRINT) == 0:\n print('+> Calculating synthetic riverbed topography...', end='')\n beck_bed = compute_beck(cur, s)\n beck_bed[np.abs(beck_bed)<ZERO] = 0\n if np.mod(t, LPRINT) == 0:\n print(' [done]')\n return beck_bed",
"def bcL(self, rng=No... | [
"0.5774911",
"0.56372297",
"0.55830455",
"0.5558612",
"0.5527662",
"0.54958844",
"0.54610884",
"0.545397",
"0.5450368",
"0.54146516",
"0.540978",
"0.5405097",
"0.54040176",
"0.5401028",
"0.54001254",
"0.5399316",
"0.53932416",
"0.5379748",
"0.53642637",
"0.534697",
"0.5338786... | 0.0 | -1 |
Compute left and right offset polylines of centerline with an offset distance of L. Thank Y. Luo for improving the offsetting method. | def offset(x, y, L):
length = x.size
offsetx = np.zeros((length, 2))
offsety = np.zeros((length, 2))
dx = np.zeros(length-1)
dy = np.zeros(length-1)
dxL = np.zeros(length-1)
dyL = np.zeros(length-1)
xl = np.zeros(length) # counterclockwise
xr = np.zeros(length) # clockwise
yl = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_laneOffset(self):\n center_line = np.poly1d(np.mean([self.line_l.get_LinePoly().coeffs, self.line_r.get_LinePoly().coeffs], axis=0))\n # store the center line polynomial\n self.center_poly = center_line\n center_point = IMAGE_WIDTH/2 - center_line(709)\n offset_from_c... | [
"0.74781597",
"0.6577585",
"0.6375418",
"0.6173955",
"0.6073473",
"0.6069938",
"0.597449",
"0.59539807",
"0.59206563",
"0.5882129",
"0.58703756",
"0.5837737",
"0.58107406",
"0.5750666",
"0.57391214",
"0.570022",
"0.56990975",
"0.5670591",
"0.5662863",
"0.56608677",
"0.5651498... | 0.7511953 | 0 |
Compute the offset polylines of centerline. Merge coordinates data (x & y information) with bed topography data (z information) to form a point cloud dataset in 3column xyz format. | def offset_all(x, y, beck_bed, t):
length = x.size
xyz1 = np.zeros((length, 3))
xyz2 = np.zeros((length, 3))
xyz1[:, 0] = np.copy(x)
xyz1[:, 1] = np.copy(y)
xyz1[:, 2] = np.copy(beck_bed[:, NUM])
allxyz = np.copy(xyz1)
offsetx = np.zeros((length, 2))
offsety = np.zeros((length, 2))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process_laneOffset(self):\n center_line = np.poly1d(np.mean([self.line_l.get_LinePoly().coeffs, self.line_r.get_LinePoly().coeffs], axis=0))\n # store the center line polynomial\n self.center_poly = center_line\n center_point = IMAGE_WIDTH/2 - center_line(709)\n offset_from_c... | [
"0.6411391",
"0.57164943",
"0.5699968",
"0.5545373",
"0.5483594",
"0.53743315",
"0.5361134",
"0.5352067",
"0.5319823",
"0.5315895",
"0.53050673",
"0.53008056",
"0.52951145",
"0.5254391",
"0.5216338",
"0.5214085",
"0.51875794",
"0.51854825",
"0.51789796",
"0.51682115",
"0.5153... | 0.49207258 | 38 |
Write the point cloud of riverbed topography data. | def write_xyz_file(allxyz):
if SAVEXYZ:
print('+> Saving riverbed topography file...', end='')
if MODE == 1:
np.savetxt('kinoshita_topo.xyz', allxyz, fmt='%.6e')
elif MODE == 2:
np.savetxt(FNAME.rsplit('.', 1)[0] + '_topo.xyz', allxyz, fmt='%.6e')
print(' [don... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def writePointCloudVTP(self, outFile):\n #points\n vtkPts = vtk.vtkPoints()\n cells = vtk.vtkCellArray()\n\n # setup colors\n Colors = vtk.vtkFloatArray()\n #Colors.SetNumberOfComponents(3)\n Colors.SetNumberOfTuples(self.Npts)\n Colors.SetName(self.label) #c... | [
"0.676081",
"0.61430436",
"0.6105673",
"0.5979034",
"0.59036213",
"0.5813448",
"0.5647733",
"0.5640388",
"0.55900574",
"0.55822045",
"0.55764955",
"0.55333817",
"0.55268365",
"0.55162495",
"0.5514892",
"0.5493977",
"0.54869837",
"0.54302067",
"0.54266334",
"0.5345584",
"0.534... | 0.54841113 | 17 |
Build and write the finite element mesh (noncompuational). | def write_mesh_file(allxyz, beck_bed):
if SAVEMESH:
print('+> Saving finite element mesh files...', end='')
fname = FNAME.rsplit('.', 1)[0]
ncol = beck_bed[0,:].size
nrow = beck_bed[:,0].size
nele = (nrow-1)*(ncol-1)*2
d = compute_mesh(nrow, ncol, nele)
h = ':... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def CreateDummyUpperDimensionalMesh(self):\n\n\n sys.stdout = open(os.devnull, \"w\")\n p = self.InferPolynomialDegree()\n mesh = Mesh()\n if self.element_type == \"tri\":\n mesh.Parallelepiped(nx=1,ny=1,nz=1, element_type=\"tet\")\n mesh.GetHighOrderMesh(p=p)\n ... | [
"0.67319965",
"0.6486597",
"0.641751",
"0.6250623",
"0.611316",
"0.6060483",
"0.6028214",
"0.5988006",
"0.59420913",
"0.59015757",
"0.5859401",
"0.5840814",
"0.5839659",
"0.5817488",
"0.581355",
"0.57974845",
"0.5776498",
"0.57728815",
"0.5749524",
"0.57306874",
"0.57267076",... | 0.72402173 | 0 |
Build the finite element mesh (compuational). Numba nopyton mode is on. | def compute_mesh(nrow, ncol, nele):
tri_index = np.zeros((nele, 3))
for i in range(nrow-1):
for j in range(NUM):
if j == 0:
tri_index[i*4*NUM+j*4, 0] = (i+1)+(2*j+1)*nrow
tri_index[i*4*NUM+j*4, 1] = (i+1)
tri_index[i*4*NUM+j*4, 2] = (i+2)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_forces_mesh(self):\n f = self.ptclgrid.grid[:self.size,:self.size]*self.grad_phi_mesh()\n return f",
"def construct_linear_system(self):\n N=self.grid.Ncells()\n Nbc = len(self.dirichlet_bcs)\n self.Ncalc=Ncalc = N - Nbc\n\n # map cells to forced values\n ... | [
"0.6277017",
"0.60608715",
"0.6025423",
"0.5964582",
"0.59430224",
"0.59073764",
"0.58610296",
"0.58496845",
"0.57895",
"0.57750237",
"0.5748845",
"0.5736129",
"0.5713295",
"0.56682",
"0.56620336",
"0.5630105",
"0.56182766",
"0.5547009",
"0.5531999",
"0.55184096",
"0.5491587"... | 0.53366375 | 41 |
Find neck cutoff. If found, remake centerline. | def cutoff(s, x, y):
oxbowx, oxbowy = np.zeros(0), np.zeros(0)
found_cutoff = False
if MIGRATION:
for i in range(1, s.size):
for j in range(1, s.size):
if j-i > 4*NUM and np.sqrt((x[i]-x[j])**2+(y[i]-y[j])**2) < WIDTH:
oxbowx, oxbowy = np.copy(x[i+1:j... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cutout(self, centre, radius):",
"def cut_neck(template, r0, c0, r1, c1):\n # rr, cc, _ = line_aa(r0, c0, r1, c1)\n rr, cc = line(r0, c0, r1, c1)\n template[rr, cc] = 0\n return template",
"def _compute_cutoffs(self):\n self._cutoffidx=np.zeros(self.nsamples,dtype=np.int)\n # Find ... | [
"0.5898544",
"0.5584039",
"0.54813856",
"0.547844",
"0.53881294",
"0.5382743",
"0.5365016",
"0.5333634",
"0.5280446",
"0.52618206",
"0.5255998",
"0.51932687",
"0.51894706",
"0.51854175",
"0.50618666",
"0.5061274",
"0.49788883",
"0.49771476",
"0.49672613",
"0.49562556",
"0.495... | 0.51696855 | 14 |
Make channel migration movie in gif format. | def make_gif():
if MIGRATION:
import imageio
for n, JPG_DIR in enumerate(JPG_DIRS):
images, image_file_names = [], []
for file_name in os.listdir(JPG_DIR):
if file_name.endswith('.jpg'):
image_file_names.append(file_name)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_gif(ctx):\n ctx.run(\n 'ffmpeg '\n '-i resources/demo.mkv -filter_complex \"[0:v] palettegen\" '\n 'resources/palette.png',\n pty=True\n )\n ctx.run(\n 'ffmpeg -i resources/demo.mkv '\n '-i resources/palette.png '\n '-filter_complex \"[0:v][1:v]... | [
"0.7008671",
"0.6884192",
"0.6653024",
"0.64807695",
"0.6446074",
"0.6423537",
"0.636852",
"0.63599503",
"0.6167705",
"0.61626273",
"0.6134406",
"0.6128358",
"0.6097842",
"0.6088125",
"0.6085878",
"0.6074961",
"0.6070263",
"0.606446",
"0.6043163",
"0.59980667",
"0.59119076",
... | 0.6775056 | 2 |
Clean cache if there is any. Print job done. | def job_done():
try:
shutil.rmtree('__pycache__')
except OSError:
pass
print('+> My job is done\n')
input('Press <Enter> to quit\n') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_cache_step(self):\n logger.info('Step {}, cleaning cache'.format(self.name))\n self.output = None\n return self",
"def clean_cache(self):\n return",
"def clear_cache():\n # TODO\n pass",
"def clear_cache(self):\n pass",
"def _purge():\r\n _cache... | [
"0.7725692",
"0.7319051",
"0.7011005",
"0.6974307",
"0.69056773",
"0.6748821",
"0.6717088",
"0.67004144",
"0.6688451",
"0.6663096",
"0.6618994",
"0.66112363",
"0.66062546",
"0.6599757",
"0.655827",
"0.6533588",
"0.6507623",
"0.64878786",
"0.6484797",
"0.6472741",
"0.64311296"... | 0.6479549 | 19 |
Execute the workflow of pyRiverBed. | def main():
print_banner()
params = read_steering()
s, x, y, cur, theta = build_kinoshita()
s, x, y, cur, theta = read_centerline(s, x, y, cur, theta)
s, x, y, cur, theta = extend_centerline(s, x, y, cur, theta)
for t in range(TSTEPS+1):
cur, theta = tan2curv(s, x, y)
cur_ori = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n parser = argparse.ArgumentParser()\n parser.add_argument('--viewer', '-v', type=str, default='interactivemarker',\n help='The viewer to attach (none for no viewer)')\n parser.add_argument('--monitor', action='store_true',\n help='Display a UI to ... | [
"0.6846046",
"0.6794627",
"0.67054456",
"0.6396308",
"0.63676095",
"0.631021",
"0.6250054",
"0.6245897",
"0.6202542",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
"0.6198228",
... | 0.0 | -1 |
Generate a rustanalyzer compatible rustproject.json file. | def generate_rust_project_json(self) -> None:
if not self.rust_crates:
return
with open(os.path.join(self.environment.get_build_dir(), 'rust-project.json'),
'w', encoding='utf-8') as f:
json.dump(
{
"sysroot_src": os.path.join... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createproject(destinationdir):\n print(f\"Writing json data files to {destinationdir}\")\n return",
"def projectToJSONFile(projectPath):\n jsonProjectFileName = projectPath.split('.')[0] + '_summary.json'\n jsonProject = projectToJSON(projectPath)\n with open (jsonProjectFileName, 'w') as outF... | [
"0.5765005",
"0.5750292",
"0.56758595",
"0.5569898",
"0.55584913",
"0.547835",
"0.547835",
"0.547835",
"0.5442536",
"0.5390132",
"0.5291652",
"0.52869755",
"0.5279458",
"0.52660453",
"0.525721",
"0.52367043",
"0.5209489",
"0.52066916",
"0.5184295",
"0.51825064",
"0.5129931",
... | 0.69861084 | 0 |
Returns a dictionary with the keys being the path to the file (relative to the build directory) and the value being the File object representing the same path. | def get_target_generated_sources(self, target: build.BuildTarget) -> T.MutableMapping[str, File]:
srcs: T.MutableMapping[str, File] = OrderedDict()
for gensrc in target.get_generated_sources():
for s in gensrc.get_outputs():
rel_src = self.get_target_generated_dir(target, gen... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _file_dict(self, fn_):\n if not os.path.isfile(fn_):\n err = \"The referenced file, {} is not available.\".format(fn_)\n sys.stderr.write(err + \"\\n\")\n sys.exit(42)\n with salt.utils.files.fopen(fn_, \"r\") as fp_:\n data = fp_.read()\n return... | [
"0.6919517",
"0.6863222",
"0.63652253",
"0.62779284",
"0.60995907",
"0.5967149",
"0.595928",
"0.59572923",
"0.58941245",
"0.58785695",
"0.5851918",
"0.5772072",
"0.5767667",
"0.5758123",
"0.5751229",
"0.5726455",
"0.5722699",
"0.57208216",
"0.57204276",
"0.57001",
"0.56919104... | 0.0 | -1 |
Make source files absolute | def compute_path(file: mesonlib.FileOrString) -> str:
if isinstance(file, File):
return file.absolute_path(self.source_dir, self.build_dir)
return os.path.normpath(os.path.join(self.build_dir, file)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sources_absolute_paths(self):\r\n abs_target_base = os.path.join(get_buildroot(), self.target_base)\r\n for src in self.sources:\r\n yield os.path.join(abs_target_base, src)",
"def relative_to_buildroot(self):\n return [os.path.join(self.rel_path, source) for source in self.source_paths]",
"d... | [
"0.71705025",
"0.6414627",
"0.63732827",
"0.6066609",
"0.60212094",
"0.5882674",
"0.58711624",
"0.58533555",
"0.5799905",
"0.5785516",
"0.57765865",
"0.56890666",
"0.5666928",
"0.5614749",
"0.5548962",
"0.55128753",
"0.5511436",
"0.5492249",
"0.5454488",
"0.54247826",
"0.5424... | 0.0 | -1 |
Peek into the sources of BuildTargets we're linking with, and if any of them was built with Vala, assume that it also generated a .vapi file of the same name as the BuildTarget and return the path to it relative to the build directory. | def determine_dep_vapis(self, target):
result = OrderedSet()
for dep in itertools.chain(target.link_targets, target.link_whole_targets):
if not dep.is_linkable_target():
continue
for i in dep.sources:
if hasattr(i, 'fname'):
i =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relative_to_buildroot(self):\n return [os.path.join(self.rel_path, source) for source in self.source_paths]",
"def generate_vala_compile(self, target: build.BuildTarget) -> \\\n T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File], T.List[str]]:\n (vala_src, vapi_src, other_s... | [
"0.64123094",
"0.6297687",
"0.60322136",
"0.59872854",
"0.57505876",
"0.5746975",
"0.57446456",
"0.56533736",
"0.55476505",
"0.5485242",
"0.54734313",
"0.53989863",
"0.53819764",
"0.5362305",
"0.53325355",
"0.5314406",
"0.5299155",
"0.52888477",
"0.5238422",
"0.52343905",
"0.... | 0.5790028 | 4 |
Splits the target's sources into .vala, .gs, .vapi, and other sources. Handles both preexisting and generated sources. Returns a tuple (vala, vapi, others) each of which is a dictionary with the keys being the path to the file (relative to the build directory) and the value being the object that generated or represents... | def split_vala_sources(self, t: build.BuildTarget) -> \
T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File],
T.Tuple[T.MutableMapping[str, File], T.MutableMapping]]:
vala: T.MutableMapping[str, File] = OrderedDict()
vapi: T.MutableMapping[str, File] = Ordered... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_vala_compile(self, target: build.BuildTarget) -> \\\n T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File], T.List[str]]:\n (vala_src, vapi_src, other_src) = self.split_vala_sources(target)\n extra_dep_files = []\n if not vala_src:\n raise Invalid... | [
"0.6056835",
"0.58320844",
"0.56975776",
"0.5695355",
"0.56941354",
"0.56379557",
"0.55843604",
"0.5572055",
"0.5410893",
"0.535213",
"0.5313574",
"0.53130484",
"0.530888",
"0.52893823",
"0.5281984",
"0.5279749",
"0.5272755",
"0.5268782",
"0.5266625",
"0.52504265",
"0.5248615... | 0.785854 | 0 |
Vala is compiled into C. Set up all necessary build steps here. | def generate_vala_compile(self, target: build.BuildTarget) -> \
T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File], T.List[str]]:
(vala_src, vapi_src, other_src) = self.split_vala_sources(target)
extra_dep_files = []
if not vala_src:
raise InvalidArguments(f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def setup_glibc():\n if not os.path.exists(glibc_build_dir):\n docmd(\"mkdir %s\" % glibc_build_dir)\n glibc_subdir = \"glibc-%s\" % glibc_version\n if not os.path.exists(glibc_subdir):\n docmd(\"wget http://ftpmirror.gnu.org/glibc/\"\n \"%s.tar.bz2\" % glibc_subdir)\n docmd(\"tar jxf %s.tar.b... | [
"0.5602567",
"0.543335",
"0.53301674",
"0.5304108",
"0.5286191",
"0.52635735",
"0.5227829",
"0.51943076",
"0.5164394",
"0.51239663",
"0.5060787",
"0.50462466",
"0.5021612",
"0.4998351",
"0.4991233",
"0.4991233",
"0.49836853",
"0.4957573",
"0.494618",
"0.49404785",
"0.49330255... | 0.64493704 | 0 |
Generate rules for transpiling Cython files to C or C++ | def generate_cython_transpile(self, target: build.BuildTarget) -> \
T.Tuple[T.MutableMapping[str, File], T.MutableMapping[str, File], T.List[str]]:
static_sources: T.MutableMapping[str, File] = OrderedDict()
generated_sources: T.MutableMapping[str, File] = OrderedDict()
cython_source... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pyo():\n local('python -O -m compileall .')",
"def pyo():\n local('python -O -m compileall .')",
"def compile_cutils():\r\n\r\n types = ['npy_' + t for t in ['int8', 'int16', 'int32', 'int64', 'int128',\r\n 'int256', 'uint8', 'uint16', 'uint32', 'uint64', 'uint128', 'uint256',\r\n 'f... | [
"0.644899",
"0.644899",
"0.63634294",
"0.63512045",
"0.6192792",
"0.6134807",
"0.5765677",
"0.5760449",
"0.5747454",
"0.5743692",
"0.56498545",
"0.5609859",
"0.55956745",
"0.5582601",
"0.5581401",
"0.5578906",
"0.5548663",
"0.5526328",
"0.55054164",
"0.5475244",
"0.54675543",... | 0.65219265 | 0 |
Create a target to copy a source file from one location to another. | def _generate_copy_target(self, src: 'mesonlib.FileOrString', output: Path) -> None:
if isinstance(src, File):
instr = src.absolute_path(self.environment.source_dir, self.environment.build_dir)
else:
instr = src
elem = NinjaBuildElement(self.all_outputs, [str(output)], 'C... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self, src_path: str, tgt_path: str) -> None:",
"def copyfile(self, source, outputfile):\n shutil.copyfileobj(source, outputfile)",
"def copyfile(self, source, outputfile):\n shutil.copyfileobj(source, outputfile)",
"def copyfile(self, source, outputfile):\n shutil.copyfileobj(so... | [
"0.73829716",
"0.7333408",
"0.7333408",
"0.7333408",
"0.732937",
"0.7263016",
"0.7261521",
"0.7118045",
"0.71087444",
"0.697479",
"0.6830899",
"0.656345",
"0.6529164",
"0.64964",
"0.6474932",
"0.6473316",
"0.64412814",
"0.64376616",
"0.6422596",
"0.6418557",
"0.6409707",
"0... | 0.7072387 | 9 |
Helper method to get rsp options. rsp_file_syntax() is only guaranteed to be implemented if can_linker_accept_rsp() returns True. | def _rsp_options(self, tool: T.Union['Compiler', 'StaticLinker', 'DynamicLinker']) -> T.Dict[str, T.Union[bool, RSPFileSyntax]]:
options = {'rspable': tool.can_linker_accept_rsp()}
if options['rspable']:
options['rspfile_quote_style'] = tool.rsp_file_syntax()
return options | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_options(ret):\n attrs = {\"host\": \"host\", \"port\": \"port\", \"skip\": \"skip_on_error\", \"mode\": \"mode\"}\n\n _options = salt.returners.get_returner_options(\n __virtualname__, ret, attrs, __salt__=__salt__, __opts__=__opts__\n )\n return _options",
"def compilation_options(se... | [
"0.50831187",
"0.4936194",
"0.4710779",
"0.4703603",
"0.47000256",
"0.46416172",
"0.46384525",
"0.46382034",
"0.46292686",
"0.45956933",
"0.45816252",
"0.4573522",
"0.45415303",
"0.45326465",
"0.45186582",
"0.44897",
"0.44642767",
"0.44639853",
"0.4455904",
"0.44428545",
"0.4... | 0.7745526 | 0 |
Find all module and submodule made available in a Fortran code file. | def scan_fortran_module_outputs(self, target):
if self.use_dyndeps_for_fortran():
return
compiler = None
# TODO other compilers
for lang, c in self.environment.coredata.compilers.host.items():
if lang == 'fortran':
compiler = c
brea... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_modules(x):\n return Path(x).rglob('*.py')",
"def findModule(name):",
"def _scan_fortran_file_deps(src: Path, srcdir: Path, dirname: Path, tdeps, compiler) -> T.List[str]:\n\n incre = re.compile(FORTRAN_INCLUDE_PAT, re.IGNORECASE)\n usere = re.compile(FORTRAN_USE_PAT, re.IGNORECASE)\n subm... | [
"0.6819265",
"0.65223193",
"0.652114",
"0.6389625",
"0.6138241",
"0.6116626",
"0.60589266",
"0.60463464",
"0.59813786",
"0.5934519",
"0.5933643",
"0.5903426",
"0.5874463",
"0.5871645",
"0.5862996",
"0.5855652",
"0.58545387",
"0.58485526",
"0.58388484",
"0.58376634",
"0.576273... | 0.58034265 | 20 |
Find all module and submodule needed by a Fortran target | def get_fortran_deps(self, compiler: FortranCompiler, src: Path, target) -> T.List[str]:
if self.use_dyndeps_for_fortran():
return []
dirname = Path(self.get_target_private_dir(target))
tdeps = self.fortran_deps[target.get_basename()]
srcdir = Path(self.source_dir)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scan_fortran_module_outputs(self, target):\n if self.use_dyndeps_for_fortran():\n return\n compiler = None\n # TODO other compilers\n for lang, c in self.environment.coredata.compilers.host.items():\n if lang == 'fortran':\n compiler = c\n ... | [
"0.7063762",
"0.6719846",
"0.6627496",
"0.6324317",
"0.6165657",
"0.6095867",
"0.60750175",
"0.6055428",
"0.6054418",
"0.60239345",
"0.59913206",
"0.597504",
"0.5936399",
"0.59242594",
"0.5907928",
"0.58924717",
"0.5890326",
"0.58276814",
"0.5796725",
"0.57962143",
"0.5789822... | 0.60256124 | 9 |
Compiles C/C++, ObjC/ObjC++, Fortran, and D sources | def generate_single_compile(self, target: build.BuildTarget, src,
is_generated=False, header_deps=None,
order_deps: T.Optional[T.List['mesonlib.FileOrString']] = None,
extra_args: T.Optional[T.List[str]] = None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def pyo():\n local('python -O -m compileall .')",
"def pyo():\n local('python -O -m compileall .')",
"def build_program(source_files, image_type='bare-metal', opt_level='-O3', cflags=None):\n assert isinstance(source_files, list)\n\n if not os.path.exists(OBJ_DIR):\n os.makedirs(OBJ_DIR)\n\n... | [
"0.6460845",
"0.6460845",
"0.6460829",
"0.6281568",
"0.62301815",
"0.6133531",
"0.6118104",
"0.6079851",
"0.6027266",
"0.6002802",
"0.5884031",
"0.5878032",
"0.5852781",
"0.5839785",
"0.5818881",
"0.5815626",
"0.5788101",
"0.57821906",
"0.57686496",
"0.5767464",
"0.57662016",... | 0.0 | -1 |
scan a Fortran file for dependencies. Needs to be distinct from target to allow for recursion induced by `include` statements.er It makes a number of assumptions, including `use`, `module`, `submodule` name is not on a continuation line Regex `incre` works for `include "foo.f90"` and `include "foo.f90"` `usere` works f... | def _scan_fortran_file_deps(src: Path, srcdir: Path, dirname: Path, tdeps, compiler) -> T.List[str]:
incre = re.compile(FORTRAN_INCLUDE_PAT, re.IGNORECASE)
usere = re.compile(FORTRAN_USE_PAT, re.IGNORECASE)
submodre = re.compile(FORTRAN_SUBMOD_PAT, re.IGNORECASE)
mod_files = []
src = Path(src)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scan_fortran_module_outputs(self, target):\n if self.use_dyndeps_for_fortran():\n return\n compiler = None\n # TODO other compilers\n for lang, c in self.environment.coredata.compilers.host.items():\n if lang == 'fortran':\n compiler = c\n ... | [
"0.66169536",
"0.61312497",
"0.58868647",
"0.5637438",
"0.55885524",
"0.5586976",
"0.5523092",
"0.5467778",
"0.5432288",
"0.5417047",
"0.5335516",
"0.519833",
"0.51949865",
"0.51465106",
"0.5142541",
"0.5124167",
"0.5095581",
"0.50270045",
"0.5003758",
"0.49810615",
"0.494451... | 0.7567411 | 0 |
Returns a histogram over all relationships in a graph | def count_relations(graph):
return Counter(
data[RELATION]
for _, _, data in graph.edges_iter(data=True)
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_unique_relations(graph):\n return Counter(itt.chain.from_iterable(get_edge_relations(graph).values()))",
"def multiple_connections_histogram(synapses):\n count_of_synapses = synapses.groupby(['pre', 'post']).size()\n return count_of_synapses",
"def count_pathologies(graph):\n return Count... | [
"0.69387263",
"0.6183445",
"0.6046419",
"0.6034515",
"0.59751195",
"0.57758623",
"0.57072544",
"0.5633479",
"0.5611335",
"0.56087476",
"0.55993664",
"0.5599142",
"0.55365855",
"0.5526105",
"0.54780513",
"0.547426",
"0.54703754",
"0.5457386",
"0.54382086",
"0.5435362",
"0.5413... | 0.7300097 | 0 |
Makes a dict that accumulates the values for each key in an iterator of doubles | def group_dict_set(iterator):
d = defaultdict(set)
for key, value in iterator:
d[key].add(value)
return dict(d) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_densities(densities):\n\n return {spin: sum(np.array(dens[spin]) for dens in densities) \n for spin in densities[0].keys()}",
"def build_histogram(iterator, key):\n buckets = defaultdict(int)\n values = {}\n\n num_objects = 0\n for obj in iterator:\n num_objects += 1\n\n ... | [
"0.6195448",
"0.5842633",
"0.5762505",
"0.5756769",
"0.5659886",
"0.5645777",
"0.5627008",
"0.5534746",
"0.5509884",
"0.55032265",
"0.54376537",
"0.54350764",
"0.54216063",
"0.5409323",
"0.540671",
"0.5402735",
"0.53859186",
"0.53531986",
"0.53487366",
"0.5334113",
"0.5327092... | 0.61645067 | 1 |
Returns a histogram of the different types of relations present in a graph. | def count_unique_relations(graph):
return Counter(itt.chain.from_iterable(get_edge_relations(graph).values())) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )",
"def relationship_types(self):\n return frozenset(self._relationships_by_type.keys())",
"def get_all_relations(graph, u, v):\n return {\n data[RELATION]\n ... | [
"0.7243773",
"0.5846342",
"0.5788476",
"0.5771844",
"0.5683003",
"0.55974525",
"0.5592673",
"0.55913526",
"0.55775154",
"0.5538538",
"0.55222",
"0.55188054",
"0.53761876",
"0.53658545",
"0.5363041",
"0.5343787",
"0.529524",
"0.52806026",
"0.5279505",
"0.5273678",
"0.5265037",... | 0.6904264 | 1 |
Iterates over the annotation keys | def _annotation_iter_helper(graph):
return (
key
for _, _, data in graph.edges(data=True)
if ANNOTATIONS in data
for key in data[ANNOTATIONS]
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iterkeys(self):",
"def iterkeys(self):",
"def iter_keypoints_labels(self):\n return iter(self.schema)",
"def _key_index_iter(self: Any) -> Iterator[Tuple[str, Any]]:\n for k, v in vars(self).items():\n yield k, v",
"def iterate_keys(\n self,\n keys: istr = None,\n ... | [
"0.6948478",
"0.6948478",
"0.6455085",
"0.6263266",
"0.6235896",
"0.6149486",
"0.6079361",
"0.59984857",
"0.5966069",
"0.5909791",
"0.5881101",
"0.585842",
"0.5820509",
"0.58111554",
"0.5806297",
"0.58045775",
"0.5788105",
"0.5782316",
"0.5751768",
"0.5739767",
"0.5723479",
... | 0.69208306 | 2 |
Counts how many times each annotation is used in the graph | def count_annotations(graph):
return Counter(_annotation_iter_helper(graph)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_annotation_values(graph, annotation):\n return Counter(iter_annotation_values(graph, annotation))",
"def get_annotation_count(self):\n return self._num_annos",
"def get_no_of_annotations(database, label, train_vids_all):\n count = 0\n for vid in train_vids_all:\n for ann in dat... | [
"0.8343825",
"0.75170594",
"0.68242604",
"0.6573023",
"0.64739114",
"0.6471781",
"0.6350306",
"0.6324876",
"0.6313155",
"0.62601817",
"0.6247608",
"0.6229666",
"0.6193566",
"0.6186364",
"0.61589694",
"0.6157267",
"0.6121791",
"0.6050442",
"0.6028076",
"0.60266453",
"0.6026645... | 0.8530131 | 0 |
Gets the set of annotations used in the graph | def get_annotations(graph):
return set(_annotation_iter_helper(graph)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def annotations(self):\n return self._annotations",
"def annotations(self):\n\n return self._annotations",
"def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations\")",
"def annotations(self) -> Mapping[str, str]:\n return pulumi.get(self, \"annotations... | [
"0.8111795",
"0.8045864",
"0.7362889",
"0.7362889",
"0.7331711",
"0.70147973",
"0.69533426",
"0.69257975",
"0.69232273",
"0.69228804",
"0.68237376",
"0.6820551",
"0.6820551",
"0.67251045",
"0.6618748",
"0.6587142",
"0.65761614",
"0.652672",
"0.6499983",
"0.6469789",
"0.633797... | 0.8332945 | 0 |
Gets the set of all annotations that are defined in a graph, but are never used. | def get_unused_annotations(graph):
return graph.defined_annotation_keywords - get_annotations(graph) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_annotations(graph):\n return set(_annotation_iter_helper(graph))",
"def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))",
"def get_unused_list_annotation_values(graph):\n result = {}\n for annotation, values in graph.annotation_list.items():... | [
"0.8046899",
"0.6747276",
"0.6727379",
"0.6385317",
"0.6370691",
"0.6229582",
"0.6198001",
"0.59983647",
"0.5742247",
"0.57196945",
"0.5694495",
"0.5674026",
"0.56460255",
"0.56373686",
"0.56286234",
"0.55884176",
"0.55659765",
"0.55608773",
"0.5503239",
"0.5494925",
"0.54823... | 0.79468316 | 1 |
Gets all of the unused values for list annotations | def get_unused_list_annotation_values(graph):
result = {}
for annotation, values in graph.annotation_list.items():
used_values = get_annotation_values(graph, annotation)
if len(used_values) == len(values): # all values have been used
continue
result[annotation] = set(values)... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_unused_annotations(graph):\n return graph.defined_annotation_keywords - get_annotations(graph)",
"def get_annotation_values(graph, annotation):\n return set(iter_annotation_values(graph, annotation))",
"def metric_annotations_allow_list(self) -> Optional[pulumi.Input[str]]:\n return pulumi... | [
"0.68537354",
"0.62805945",
"0.59040225",
"0.589097",
"0.58017445",
"0.575836",
"0.5727465",
"0.57149005",
"0.56691",
"0.56430316",
"0.56349885",
"0.5633079",
"0.55975",
"0.55915046",
"0.55841595",
"0.5538164",
"0.5534096",
"0.5508441",
"0.5505978",
"0.55038834",
"0.54778254"... | 0.7874108 | 0 |
Gets annotation/value pairs for values for whom the search string is a substring | def get_annotations_containing_keyword(graph, keyword):
return [
{
'annotation': annotation,
'value': value
}
for annotation, value in iter_annotation_value_pairs(graph)
if keyword.lower() in value.lower()
] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _substring_occurrences(\n cls, in_str: str, substrings: Iterable[str]\n ) -> Dict[str, List[int]]:\n occurrences = {}\n for substring in substrings:\n occurrences[substring] = list(findall(substring, in_str))\n return occurrences",
"def search_in_tree(self, tree, sub... | [
"0.5903146",
"0.5488121",
"0.5460287",
"0.5396356",
"0.53472704",
"0.5338512",
"0.53332084",
"0.5275697",
"0.5245533",
"0.5171115",
"0.51687026",
"0.5167059",
"0.5165257",
"0.51592106",
"0.5158753",
"0.5154511",
"0.5152063",
"0.5150403",
"0.5129545",
"0.51103365",
"0.51068866... | 0.576712 | 1 |
Counts in how many edges each annotation appears in a graph | def count_annotation_values(graph, annotation):
return Counter(iter_annotation_values(graph, annotation)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))",
"def edgecount(self):\n\n raise NotImplementedError",
"def num_edges(g):\n total_edges_with_duplicates = sum(len(v) for v in g.values())\n return total_edges_with_duplicates // 2",
"def edge_count(self) -> int:\n... | [
"0.8137551",
"0.73022085",
"0.6926789",
"0.69061303",
"0.68878543",
"0.6854445",
"0.67950374",
"0.6794573",
"0.67014533",
"0.6696235",
"0.6683472",
"0.66686267",
"0.6668122",
"0.6655918",
"0.6652132",
"0.6610412",
"0.65590703",
"0.65477306",
"0.6536954",
"0.6498154",
"0.64939... | 0.7824741 | 1 |
Get all values for the given annotation | def get_annotation_values(graph, annotation):
return set(iter_annotation_values(graph, annotation)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_annotations(self):\n entity = self.get_object()\n serializer = AnnotationValueSerializer(entity.annotations.all(), many=True)\n return Response(serializer.data)",
"def handle_enum(enum_annotations: Any) -> list:\n result = []\n for attribute in list(enum_annotations):\n... | [
"0.67769945",
"0.6325543",
"0.6274638",
"0.6220138",
"0.6180968",
"0.6171129",
"0.61034197",
"0.60787046",
"0.60713106",
"0.6068879",
"0.5992964",
"0.59564936",
"0.59216946",
"0.59216946",
"0.59015006",
"0.5887698",
"0.5887698",
"0.5886613",
"0.5818207",
"0.5798842",
"0.57982... | 0.75477934 | 0 |
Counts in how many edges each annotation appears in a graph, but filter out source nodes and target nodes | def count_annotation_values_filtered(graph, annotation, source_filter=None, target_filter=None):
source_filter = keep_node_permissive if source_filter is None else source_filter
target_filter = keep_node_permissive if target_filter is None else target_filter
return Counter(
data[ANNOTATIONS][annota... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_annotations(graph):\n return Counter(_annotation_iter_helper(graph))",
"def compute_num_edges(graph):\n # return the number of edges\n return sum([len(graph[source_node].keys()) for source_node in graph.keys()]) / 2",
"def count_annotation_values(graph, annotation):\n return Count... | [
"0.64924645",
"0.61406404",
"0.60482",
"0.5913293",
"0.5882233",
"0.5866123",
"0.5851271",
"0.58161896",
"0.57976633",
"0.57823884",
"0.57695407",
"0.57527435",
"0.56889486",
"0.5676223",
"0.5665394",
"0.5659691",
"0.5659477",
"0.56017035",
"0.556301",
"0.5519132",
"0.5494026... | 0.7213139 | 0 |
Iterates over unique nodenode pairs in the graph | def _iter_pairs(graph):
for u, v in set(graph.edges_iter()):
yield u, v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target",
"def iter_nodes(self):",
"def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))",
"def nodes(self):\n for n... | [
"0.68542266",
"0.6712754",
"0.6575832",
"0.6528945",
"0.64538825",
"0.6438056",
"0.6314288",
"0.62993896",
"0.6280058",
"0.6257878",
"0.62574124",
"0.625634",
"0.6213354",
"0.62093157",
"0.6184859",
"0.61808145",
"0.61796695",
"0.6145432",
"0.60995543",
"0.60977054",
"0.60902... | 0.78772706 | 0 |
Returns the set of all relations between a given pair of nodes | def get_all_relations(graph, u, v):
return {
data[RELATION]
for data in graph.edge[u][v].values()
} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_pairs(self):\n return chain(self.nx_graph.edges(), nx.non_edges(self.nx_graph))",
"def relations(self):\n return set(self.triples()[\"relation\"])",
"def get_relations(self):\n triples = list(self.get_triples())\n\n for s, p, o in triples:\n if not p.startswith(\"... | [
"0.70479345",
"0.6927845",
"0.6710669",
"0.6699805",
"0.6634587",
"0.65720505",
"0.6555457",
"0.65286154",
"0.6481142",
"0.6458834",
"0.64464796",
"0.63734806",
"0.6327714",
"0.6283819",
"0.6210741",
"0.6195693",
"0.61790866",
"0.61713094",
"0.616871",
"0.61438185",
"0.613430... | 0.6073819 | 24 |
Returns if the edges between the given nodes are consistent, meaning they all have the same relation | def pair_is_consistent(graph, u, v):
relations = get_all_relations(graph, u, v)
if 1 != len(relations):
return False
return list(relations)[0] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __has_multiple_edges(self):\n return \\\n len(\n list(\n [\n tuple((edge.get_first_incident_node().get_name(), edge.get_second_incident_node().get_name()))\n for edge in self.get_edges()\n ] # ... | [
"0.710841",
"0.68671525",
"0.6761228",
"0.66784406",
"0.66491693",
"0.66183716",
"0.6618279",
"0.65234625",
"0.6509124",
"0.64982206",
"0.6469651",
"0.644774",
"0.6418613",
"0.6405866",
"0.6381723",
"0.6370003",
"0.63498205",
"0.6347336",
"0.63372046",
"0.62504184",
"0.622850... | 0.6281837 | 19 |
Returns if the set of relations contains a contradiction | def relation_set_has_contradictions(relations):
has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)
has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)
has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)
return 1 < sum([... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_relations(self, relations):\n if self.debug:\n print(\"Checking relations\")\n result = False\n work_relations = []\n\n # Eliminate unnecessary(duplicated) clauses\n if relations[\"is_derived_from\"]:\n relations[\"has_derived_form\"] = True\n ... | [
"0.7122376",
"0.67345405",
"0.6449695",
"0.6206758",
"0.6205824",
"0.6188202",
"0.61652434",
"0.61545885",
"0.6087285",
"0.60733366",
"0.6025005",
"0.6013213",
"0.60035706",
"0.5984546",
"0.59587294",
"0.5939061",
"0.5924129",
"0.5839123",
"0.5822666",
"0.5814324",
"0.5813227... | 0.7635147 | 0 |
Checks if a pair of nodes has any contradictions in their causal relationships. | def pair_has_contradiction(graph, u, v):
relations = get_all_relations(graph, u, v)
return relation_set_has_contradictions(relations) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def relation_set_has_contradictions(relations):\n has_increases = any(relation in CAUSAL_INCREASE_RELATIONS for relation in relations)\n has_decreases = any(relation in CAUSAL_DECREASE_RELATIONS for relation in relations)\n has_cnc = any(relation == CAUSES_NO_CHANGE for relation in relations)\n return ... | [
"0.68102324",
"0.6214052",
"0.6207057",
"0.60906833",
"0.6065176",
"0.60568976",
"0.6026552",
"0.6008109",
"0.59604144",
"0.59581804",
"0.59490097",
"0.5934767",
"0.5910104",
"0.59072256",
"0.5901164",
"0.5900084",
"0.58665067",
"0.58433616",
"0.5840681",
"0.5824252",
"0.5824... | 0.62543714 | 1 |
Iterates over contradictory node pairs in the graph based on their causal relationships | def get_contradictory_pairs(graph):
for u, v in _iter_pairs(graph):
if pair_has_contradiction(graph, u, v):
yield u, v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_successors(self, node):\n succs = []\n parent_state = self.node_to_state(node)\n for it in self.children:\n child_node = (node[0] + it[0], node[1] + it[1])\n child_state = self.node_to_state(child_node)\n edge = self.interpolate(parent_state, child_state, self.distance_bw_states(pa... | [
"0.6238017",
"0.5909709",
"0.5907469",
"0.58362544",
"0.57939804",
"0.5792186",
"0.5703263",
"0.5681727",
"0.56771266",
"0.5671722",
"0.56632626",
"0.5611376",
"0.5602615",
"0.559068",
"0.5563447",
"0.5538029",
"0.55253816",
"0.55157125",
"0.5515107",
"0.5483767",
"0.5442139"... | 0.69560146 | 0 |
Yields pairs of (source node, target node) for which all of their edges have the same type of relation. | def get_consistent_edges(graph):
for u, v in _iter_pairs(graph):
if pair_is_consistent(graph, u, v):
yield u, v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _iter_pairs(graph):\n for u, v in set(graph.edges_iter()):\n yield u, v",
"def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target",
"def all_pairs(self):\n return chain(self.nx_graph.edges(), n... | [
"0.6733386",
"0.66894716",
"0.6501065",
"0.6438232",
"0.6384303",
"0.6357606",
"0.6318119",
"0.62464094",
"0.6178377",
"0.61569047",
"0.60460675",
"0.5998505",
"0.5993081",
"0.5944631",
"0.59069026",
"0.5852232",
"0.5815307",
"0.58126503",
"0.57924825",
"0.5792085",
"0.578729... | 0.56193626 | 31 |
Returns an iterator over inconsistent edges | def get_inconsistent_edges(graph):
for u, v in _iter_pairs(graph):
if not pair_is_consistent(graph, u, v):
yield u, v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_inconsistent_edges(graph: BELGraph) -> Iterable[Tuple[BaseEntity]]:\n for u, v in graph.edges():\n if not pair_is_consistent(graph, u, v):\n yield u, v",
"def edges(self) -> Iterable[Tuple[Node]]:\n edges = []\n for node in self.__graph_dict.keys():\n for nei... | [
"0.7528953",
"0.7357906",
"0.7300745",
"0.7209116",
"0.71582156",
"0.69598824",
"0.6937165",
"0.69073635",
"0.69073635",
"0.67656124",
"0.6638462",
"0.66057724",
"0.65948063",
"0.6583909",
"0.6570076",
"0.6515526",
"0.64862835",
"0.648145",
"0.6469323",
"0.6456677",
"0.645290... | 0.7111966 | 5 |
Iterates over the diseases encountered in edges | def _pathology_iterator(graph):
for u, v in _iter_pairs(graph):
if graph.node[u][FUNCTION] == PATHOLOGY:
yield u
if graph.node[v][FUNCTION] == PATHOLOGY:
yield v | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def iteredges(self):\n for source, targets in self.successors.items():\n for target in targets:\n yield source, target",
"def edges(self):\n for e in self._edges:\n yield e",
"def edges(self):\n return self.dovetails + self.containments + self.internals",
... | [
"0.6399897",
"0.6153952",
"0.61008126",
"0.60606647",
"0.6040917",
"0.59607315",
"0.5926328",
"0.5895811",
"0.5892186",
"0.5819291",
"0.5712466",
"0.5706369",
"0.56961864",
"0.56956095",
"0.56910306",
"0.5677939",
"0.5674862",
"0.56623685",
"0.5655787",
"0.5648146",
"0.564723... | 0.0 | -1 |
Returns a counter of all of the mentions of pathologies in a network | def count_pathologies(graph):
return Counter(_pathology_iterator(graph)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def count_relations(graph):\n return Counter(\n data[RELATION]\n for _, _, data in graph.edges_iter(data=True)\n )",
"def num_links(self):\n count=0.0\n for cluster in self.clusters:\n if self.clusters[cluster] == self.clusters[cluster].antecessor:\n numberofmembers=se... | [
"0.6493108",
"0.6265583",
"0.61763126",
"0.58439344",
"0.58234376",
"0.5724303",
"0.5712313",
"0.56395566",
"0.5600497",
"0.5599743",
"0.5586163",
"0.55701447",
"0.5519347",
"0.55081844",
"0.54878646",
"0.54671645",
"0.54594654",
"0.54498696",
"0.5437356",
"0.543203",
"0.5405... | 0.7180617 | 0 |
Create a new point at the origin | def __init__(self):
self.x = 0
self.y = 0 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clone(self):\n return Point(self.x, self.y)",
"def clone(self):\n return Point(self.x, self.y)",
"def makePoint( nX, nY ):\n oPoint = createUnoStruct( \"com.sun.star.awt.Point\" )\n oPoint.X = nX\n oPoint.Y = nY\n return oPoint",
"def makePoint( nX, nY ):\n oPoint = createUno... | [
"0.6625126",
"0.6625126",
"0.652878",
"0.652878",
"0.64970213",
"0.6491764",
"0.6487044",
"0.64737606",
"0.64691556",
"0.644956",
"0.6440114",
"0.63928",
"0.6373065",
"0.6364371",
"0.63607216",
"0.6351117",
"0.6336342",
"0.6333381",
"0.6307605",
"0.6301235",
"0.62239677",
"... | 0.0 | -1 |
method that calls the google maps API. | def find_distance(start, end, transit_mode=None):
dis_url = build_url(start, end, transit_mode)[1]
print(dis_url)
json_response = json.loads(urllib.request.urlopen(dis_url).read().decode('utf-8'))
travel_info = json_response[rows_key][0][elements_key][0]
distance = travel_info[distance_key][text_key... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def google_map_api(request):\n\treturn {\n\t\t'GOOGLE_MAPS_API' : settings.GOOGLE_MAPS_API,\n\t}",
"def googlemaps(request):\n assert False\n # return {\"GOOGLEMAPS_API_KEY\": settings.GOOGLEMAPS_API_KEY}",
"def google(self):\r\n prefix ='https://maps.googleapis.com/maps/api/staticmap?center='\... | [
"0.6655652",
"0.64451903",
"0.6228928",
"0.6192054",
"0.61880857",
"0.60813564",
"0.5891248",
"0.58714527",
"0.5839972",
"0.5789041",
"0.57397115",
"0.57201695",
"0.5664012",
"0.5558423",
"0.55010176",
"0.5402953",
"0.5361477",
"0.5352793",
"0.5310342",
"0.5282193",
"0.526921... | 0.0 | -1 |
Takes advantage of html parser as google directions api returns instructions in html. So want to strip all html tags and just return text | def find_directions(start, end, transit_mode=None):
dir_url = build_url(start, end, transit_mode)[0]
json_response = json.loads(urllib.request.urlopen(dir_url).read().decode('utf-8'))
route_legs = json_response[routes_key][0][legs_key]
directions = []
for leg in route_legs:
for step in leg[s... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_html( html):\n return html2txt(html)",
"def strip_html(text):\n soup = BeautifulSoup(text, \"html.parser\")\n return soup.get_text()",
"def strip_html(inputString):\r\n return BeautifulSoup(inputString, \"html.parser\").text",
"def strip_html_tags(text):\r\n soup = BeautifulSoup(text,... | [
"0.76679367",
"0.7576908",
"0.7565884",
"0.72577864",
"0.7234185",
"0.7175138",
"0.7175138",
"0.7033482",
"0.7032647",
"0.6952287",
"0.6933355",
"0.6921029",
"0.68994737",
"0.6894347",
"0.6892037",
"0.68644744",
"0.68379956",
"0.6834254",
"0.6825286",
"0.67909366",
"0.6725576... | 0.0 | -1 |
builds the url to get the static map. puts a marker on the start and end locations. assumes start and end are in a format / have enough info to give a proper location. does clean white spaces tho | def find_map(start, end, *otherlocs):
small = "200x200"
large = "512x512"
start = start.replace(" ","+")
end = end.replace(" ","+")
small_url = g_api_base_url + static_url + small + map_type_url + small_marker_url + start + map_concat + end
big_url = g_api_base_url + static_url + large + map_type_url + mark... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_url(self):\n if self.has_marker:\n marker_param = f'mlat={self.mlat}&mlng={self.mlng}&'\n else:\n marker_param = ''\n if self.start:\n start_param = 'start=true&'\n else:\n start_param = ''\n url = f'{MapController.MAP_URL}... | [
"0.7412921",
"0.7408514",
"0.6695499",
"0.6539618",
"0.65338993",
"0.64012855",
"0.6347697",
"0.62790763",
"0.625587",
"0.61357576",
"0.60827684",
"0.60016644",
"0.5909071",
"0.5871183",
"0.5864181",
"0.58204234",
"0.57807314",
"0.5719914",
"0.57073295",
"0.5690754",
"0.56851... | 0.74909633 | 0 |
builds urls for the directions and distance matrix apis | def build_url(start, end, transit_mode):
transit = ""
traffic = "best_guess"
depart = "now"
if transit_mode:
transit = transit_mode
direc_url = g_api_base_url + dir_url + "origin=" + start + "&destination=" + end + trans_url \
+ transit + goog_dir_key
dist_url = g_api_base_url + ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_url(_origin_details, travel_start_date, travel_start_time, destination_list):\n prefix = 'https://timetable.search.ch/api/route.json?one_to_many=1'\n\n origin_body = f'&from={_origin_details}&date={travel_start_date}&time={travel_start_time}'\n\n # Build iteratively with necessary syntax betwee... | [
"0.662632",
"0.6459529",
"0.64105844",
"0.63785255",
"0.61424583",
"0.6120072",
"0.61160785",
"0.5975166",
"0.5922255",
"0.5866318",
"0.58486396",
"0.58353645",
"0.5809004",
"0.5791701",
"0.5777878",
"0.57720447",
"0.5690597",
"0.5641834",
"0.56298447",
"0.5613718",
"0.560166... | 0.7186997 | 0 |
Calls all the map methods and returns a tuple with all the info | def get_all_map_info(start, end, transit_mode=None):
directions = find_directions(start, end, transit_mode)
distance = find_distance(start, end, transit_mode)
static_map = find_map(start, end)
return (distance, directions, static_map) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def map():",
"def map(self):\r\n pass",
"def _do_mapping(self):\n pass",
"def get_data(self) -> Tuple[PoliciesMap, ZonesMap, LinksMap]:\n return self.policies_map, self.zones_map, self.links_map",
"def _map_fn(self):\n raise NotImplementedError",
"def map( self ) :\n\n self.rea... | [
"0.73169774",
"0.66956455",
"0.64216447",
"0.62629515",
"0.62388194",
"0.61226577",
"0.60859364",
"0.60153437",
"0.5962893",
"0.5897065",
"0.5868335",
"0.58180994",
"0.5802025",
"0.57440436",
"0.57440436",
"0.5740578",
"0.5721933",
"0.5717749",
"0.57169694",
"0.5674728",
"0.5... | 0.5570534 | 24 |
Defines the way to parse the magic command ``%%maml``. | def maml_parser():
parser = MagicCommandParser(prog="maml",
description='Runs a maml script.')
parser.add_argument('-q', '--quiet', action='store_true', default=False,
help='hide output')
return parser | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maml(self, line, cell):\n parser = self.get_parser(CsMLMagics.maml_parser, \"maml\")\n args = self.get_args(line, parser)\n\n if args is not None:\n quiet = args.quiet\n out, err = maml(cell, not quiet)\n if out:\n print(out)\n if ... | [
"0.670974",
"0.5512939",
"0.51862484",
"0.5175543",
"0.50888264",
"0.49876153",
"0.49551958",
"0.49524027",
"0.49337393",
"0.4880694",
"0.48664626",
"0.48470613",
"0.4794826",
"0.47836807",
"0.4777479",
"0.47459564",
"0.47455326",
"0.4718852",
"0.46997732",
"0.46576157",
"0.4... | 0.740539 | 0 |
Defines magic command ``%%maml``. | def maml(self, line, cell):
parser = self.get_parser(CsMLMagics.maml_parser, "maml")
args = self.get_args(line, parser)
if args is not None:
quiet = args.quiet
out, err = maml(cell, not quiet)
if out:
print(out)
if err:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def maml_parser():\n parser = MagicCommandParser(prog=\"maml\",\n description='Runs a maml script.')\n parser.add_argument('-q', '--quiet', action='store_true', default=False,\n help='hide output')\n return parser",
"def command(s... | [
"0.6546807",
"0.5515294",
"0.52751005",
"0.52579564",
"0.5237155",
"0.51861405",
"0.512959",
"0.5102926",
"0.49472788",
"0.49453253",
"0.49353927",
"0.49225372",
"0.4891675",
"0.48703486",
"0.47610494",
"0.470173",
"0.46908697",
"0.4684091",
"0.46759415",
"0.4654112",
"0.4648... | 0.6613872 | 0 |
Defines the way to parse the magic command ``%%mlnet``. | def mlnet_parser():
parser = MagicCommandParser(prog="mlnet",
description='Compiles and wrap a C# function into a Python function.\n'
'Automatically adds ML.net dependencies.')
parser.add_argument('name', type=str, help=... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mlnet(self, line, cell):\n line, cell = CsMagics._preprocess_line_cell_maml( # pylint: disable=W0212\n line, cell)\n\n parser = self.get_parser(CsMagics.CS_parser, \"CS\")\n args = self.get_args(line, parser)\n\n if args is not None:\n name = args.name\n ... | [
"0.57447124",
"0.53171813",
"0.5278795",
"0.52074957",
"0.5104776",
"0.5055335",
"0.50357693",
"0.5034653",
"0.49979833",
"0.49518523",
"0.4937366",
"0.49060217",
"0.49001834",
"0.4745951",
"0.47331885",
"0.4656194",
"0.46342298",
"0.46050298",
"0.46031177",
"0.4588288",
"0.4... | 0.7271368 | 0 |
Defines magic command ``%%mlnet``. | def mlnet(self, line, cell):
line, cell = CsMagics._preprocess_line_cell_maml( # pylint: disable=W0212
line, cell)
parser = self.get_parser(CsMagics.CS_parser, "CS")
args = self.get_args(line, parser)
if args is not None:
name = args.name
dep = CsMa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mlnet_parser():\n parser = MagicCommandParser(prog=\"mlnet\",\n description='Compiles and wrap a C# function into a Python function.\\n'\n 'Automatically adds ML.net dependencies.')\n parser.add_argument('name', typ... | [
"0.6607906",
"0.5527357",
"0.54824287",
"0.5431624",
"0.54184914",
"0.54072374",
"0.53655416",
"0.52886176",
"0.5091649",
"0.49965236",
"0.4974869",
"0.49429768",
"0.49062353",
"0.48281196",
"0.48139057",
"0.4807876",
"0.47813764",
"0.47685274",
"0.47484493",
"0.47436157",
"0... | 0.5684712 | 1 |
Normalize a ND numpy array along the specified axis. | def normalize(nparray, order=2, axis=0):
norm = np.linalg.norm(nparray, ord=order, axis=axis, keepdims=True)
return nparray / (norm + np.finfo(np.float32).eps) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalize(a, axis=None):\n a_sum = a.sum(axis)\n if axis and a.ndim > 1:\n a_sum[a_sum == 0] = 1\n shape = list(a.shape)\n shape[axis] = 1\n a_sum.shape = shape\n\n return a / a_sum",
"def normalize_axis(x, axis, dtype=float):\n x = x.astype(dtype)\n ind_list = [sli... | [
"0.79087126",
"0.77035505",
"0.7302382",
"0.7287287",
"0.72832733",
"0.71538836",
"0.70283896",
"0.69810927",
"0.69810927",
"0.69810927",
"0.6960576",
"0.69318247",
"0.68613905",
"0.68207276",
"0.6742309",
"0.67182606",
"0.6710599",
"0.669388",
"0.665268",
"0.6642963",
"0.663... | 0.7220615 | 5 |
Create a pyplot plot and save to buffer. | def gen_plot(fpr, tpr):
plt.figure()
plt.xlabel("FPR", fontsize=14)
plt.ylabel("TPR", fontsize=14)
plt.title("ROC Curve", fontsize=14)
plot = plt.plot(fpr, tpr, linewidth=2)
buf = io.BytesIO()
plt.savefig(buf, format='jpeg')
buf.seek(0)
plt.close()
# plt.show()
return buf | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_plot(self, ):\n pass",
"def save_plot(self):\r\n\t\t# Generate the plot\r\n\t\tself.generate_plot()\r\n\t\t# Create save directory\r\n\t\tdirectory = self.dir + '/%s/' % str(int(self.universe.init_time))\r\n\t\tif not path_exists(directory):\r\n\t\t\tmakedirs(directory)\r\n\t\t# Save image file\r... | [
"0.6640928",
"0.63603246",
"0.6227816",
"0.6167168",
"0.61360306",
"0.6119261",
"0.6099436",
"0.6096821",
"0.60925245",
"0.60660166",
"0.60238034",
"0.60147",
"0.60147",
"0.60105187",
"0.6010414",
"0.5986429",
"0.5986346",
"0.5965323",
"0.59541225",
"0.59522265",
"0.59299445"... | 0.62246305 | 3 |
training linear classifier using stochastic gradient desent | def train(self, X, y, learning_rate = 1e-3, reg = 1e-5, num_iter = 100,
batch_size = 100, verbose = False):
num_train, dim = X.shape
num_classes = np.max(y) + 1 # assum y take values 0..K-1
# initialize weight
if self.W is None:
self.W = 0.001 * np.random... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def train(self,features,y):\r\n \r\n if self.learn_type == \"nn\":\r\n #generate supervised dataset\r\n return(self.learner.train_on_batch(features,y))\r\n elif self.learn_type == \"linear\":\r\n grad = 0\r\n n = len(features)\r\n for i in... | [
"0.7036311",
"0.6894752",
"0.6888206",
"0.6804692",
"0.6742188",
"0.6733776",
"0.6727004",
"0.67164975",
"0.6693492",
"0.666076",
"0.6657247",
"0.66092634",
"0.65603244",
"0.6525685",
"0.6510231",
"0.6499339",
"0.64880437",
"0.6471506",
"0.64697635",
"0.64687717",
"0.6464059"... | 0.0 | -1 |
predict labels for test set by using the training weight | def predict(self, X):
y_pred = np.zeros(X.shape[1])
y_pred = np.argmax(X.dot(self.W), axis = 1)
return y_pred | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def predict(test_dataset,test_tX,weights):\n for idx, dataset in enumerate(test_tX):\n test_dataset[idx]['Prediction'] = predict_labels(weights[idx],dataset)\n return test_dataset",
"def predictTest(k, train, test):\r\n\r\n pred_labels = []\r\n\r\n # for each instance in the testing dataset, c... | [
"0.78087956",
"0.7457491",
"0.733405",
"0.7281375",
"0.7198543",
"0.7198543",
"0.7198543",
"0.71389765",
"0.71339434",
"0.7059202",
"0.7003482",
"0.69429874",
"0.6942311",
"0.6911286",
"0.68954164",
"0.6894094",
"0.6872331",
"0.68667066",
"0.68229765",
"0.68118906",
"0.681115... | 0.0 | -1 |
Attach a text label above each bar in rects, displaying its height. | def autolabel(rects, r, p):
for j in range(len(rects)):
rect = rects[j]
height = rect.get_width()
# print("height: ", height)
ax.annotate( "F1: " + '{}'.format(height) + " (P: " + str(p[j]) + "; R: " + str(r[j]) + ")",
xy=(height, rect.get_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def autolabel(rects, ax):\n global BAR_NUMBER_SIZE\n for rect in rects:\n height = rect.get_height()\n ax.text(rect.get_x() + rect.get_width()/2.,\n height,\n str(round(height, 1)),\n ha ='center',\n va ='bottom',\n size... | [
"0.807113",
"0.79336554",
"0.7861467",
"0.7835557",
"0.7822906",
"0.77769476",
"0.7776375",
"0.7745001",
"0.7730597",
"0.7730573",
"0.7708679",
"0.77040344",
"0.7690377",
"0.7677892",
"0.76754576",
"0.76730984",
"0.76562864",
"0.7648832",
"0.7645011",
"0.7640306",
"0.76307166... | 0.69238454 | 80 |
Override and call super. Then do the deletion. | async def DeleteRoutine(self, name: str):
#okay. problem was being cased by this line.
#the problem is, that we delete items as part of updating
#from gitlab. And in that case, we don't want to wipe out the local config.
#so while it may seem like we should conveniently do this, probab... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete(self):\n\n raise NotImplementedError('Must be implemented by subclasses')",
"def delete(self):\n raise NotImplementedError",
"def delete(self):\n raise NotImplementedError()",
"def delete(self):\n raise NotImplementedError()",
"def delete(self):\n ...",
"def ... | [
"0.8312543",
"0.8277076",
"0.8197373",
"0.8197373",
"0.81892085",
"0.81146294",
"0.81122106",
"0.81122106",
"0.81122106",
"0.81122106",
"0.776644",
"0.77381533",
"0.76547843",
"0.76547843",
"0.7546651",
"0.74831843",
"0.7471033",
"0.7380182",
"0.73753977",
"0.7372484",
"0.736... | 0.0 | -1 |
Deletes the local configuration for a container. | async def delete_local_configuration_routine(self, name: str):
plat = get_local_platform_routines()
user = LocalUserRoutines(plat)
manager = LocalContainerConfigurationManager(user)
cont = self.GetItemByName(name)
manager.DeleteByID(cont.GetID()) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove_local_config(self):\n with ignored(OSError):\n os.remove(os.path.join(self.rundir, const.LOCAL_CONFIG_FILE))",
"def delete_container(self, container: Container):",
"def delete_container(self, account, container):\n \n pass",
"def delete_container(ContainerName=None)... | [
"0.68364567",
"0.65952647",
"0.65655595",
"0.63887167",
"0.6293753",
"0.6252849",
"0.6222041",
"0.6218625",
"0.6210771",
"0.61385065",
"0.6115384",
"0.6097698",
"0.60793775",
"0.60496986",
"0.6009285",
"0.6003192",
"0.59821314",
"0.59776366",
"0.5943736",
"0.5928523",
"0.5888... | 0.7014883 | 0 |
Create a new container and put it in the local registry. | async def CreateUpdateRoutine(self, name: str):
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def container(name, ostemplate, **kwargs):\n if not openvz.exists(name):\n ctid = openvz.get_available_ctid()\n openvz.create(ctid, ostemplate=ostemplate, **kwargs)\n openvz.set(ctid, name=name)\n return Container(name)",
"def _create_container(self, container_name):\n try:\n ... | [
"0.6844575",
"0.67954034",
"0.6773649",
"0.6728745",
"0.65901256",
"0.64971393",
"0.64853096",
"0.64367366",
"0.6405615",
"0.6405615",
"0.6405615",
"0.6405615",
"0.6405615",
"0.6378271",
"0.6365454",
"0.6297557",
"0.6289078",
"0.61622214",
"0.6106284",
"0.6105109",
"0.6075229... | 0.0 | -1 |
provides list of model ids being managed by this service | def get():
return {'model_ids': mgmt.get_model_ids()} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def model_ids(self, protocol=None, groups=None):\n return [model.id for model in self.models(protocol, groups)]",
"def getIDs(self):\n return self.multiengine.getIDs()",
"def queryModelIDs(self):\n jobID = self.getJobID()\n modelCounterPairs = _clientJobsDB().modelsGetUpdateCounters(jobID)\n ... | [
"0.7586092",
"0.7151575",
"0.715052",
"0.70966995",
"0.6926851",
"0.6900199",
"0.6856862",
"0.6841992",
"0.6827314",
"0.6738882",
"0.6738882",
"0.65993893",
"0.6594838",
"0.6443746",
"0.64352286",
"0.64352286",
"0.6365598",
"0.6365598",
"0.6353262",
"0.6318382",
"0.6318382",
... | 0.70333165 | 4 |
MS Access can't handle complex Decimal types | def convert_data_type(self, datatype):
converted = Engine.convert_data_type(self, datatype)
if "NUMERIC" in converted:
converted = "NUMERIC"
elif "VARCHAR" in converted:
try:
length = int(converted.split('(')[1].split(')')[0].split(',')[0])
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_decimal_e(cursor: pyodbc.Cursor):\n value = Decimal((0, (1, 2, 3), 5)) # prints as 1.23E+7\n cursor.execute(\"create table t1(d decimal(10, 2))\")\n cursor.execute(\"insert into t1 values (?)\", value)\n result = cursor.execute(\"select * from t1\").fetchone()[0]\n assert result == value",... | [
"0.7193939",
"0.6367631",
"0.62804735",
"0.61756307",
"0.61756307",
"0.5980316",
"0.59415334",
"0.58247906",
"0.58159804",
"0.58049774",
"0.57988",
"0.57257456",
"0.57224286",
"0.5637044",
"0.5616838",
"0.5612793",
"0.5556482",
"0.5542215",
"0.5521639",
"0.54359597",
"0.54014... | 0.0 | -1 |
MS Access doesn't create databases. | def create_db(self):
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_db():\n db.create_all()\n click.echo(\"DB criado com sucesso!\")",
"def create_db():\n db.create_all()\n print(\"DB Created\")",
"def create_db():\n db.create_all()\n click.echo(\"Banco de dados criado\")",
"def create_new_db():\n global data_base, table\n data_base... | [
"0.7011877",
"0.695819",
"0.69425726",
"0.69318235",
"0.6931772",
"0.6898847",
"0.68810636",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.68499804",
"0.6847495",
"0.6831007",
"0.... | 0.6871423 | 7 |
Returns a drop table or database SQL statement. | def drop_statement(self, object_type, object_name):
drop_statement = "DROP %s %s" % (object_type, object_name)
return drop_statement | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def drop(name):\n\t\treturn \"DROP DATABASE {0};\".format(name)",
"def _get_sql_drop_table(table_attr):\n template = 'DROP TABLE IF EXISTS \"%s\" CASCADE;' % (table_attr['name'])\n return template",
"def drop_statement(self, objecttype, objectname):\n statement = Engine.drop_statement(self... | [
"0.7439682",
"0.7192483",
"0.7143962",
"0.7049561",
"0.67682046",
"0.6763672",
"0.6577111",
"0.64398366",
"0.6311948",
"0.63029295",
"0.6295627",
"0.62305164",
"0.62251985",
"0.6221728",
"0.6211469",
"0.6206424",
"0.6188908",
"0.61786735",
"0.6153751",
"0.61287767",
"0.612725... | 0.7213489 | 1 |
Perform a bulk insert. | def insert_data_from_file(self, filename):
self.get_cursor()
if self.check_bulk_insert() and self.table.header_rows < 2 and (
self.table.delimiter in ["\t", ","]):
print("Inserting data from " + os.path.basename(filename) + "...")
if self.table.delimiter == "\t":... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _insert_bulk(self, iterable):\n self.cursor.executemany(self.INSERT, iterable)\n self.conn.commit()",
"def bulkInsert(self, url, values):\n pass",
"def insertmany(cls, *args):\n return InsertQuery(cls).bulk(True).set(*args)",
"def bulk_insert(objects, model, session):\n ses... | [
"0.7786845",
"0.77852196",
"0.7621423",
"0.7350911",
"0.73435855",
"0.7124371",
"0.7046553",
"0.7034076",
"0.6918839",
"0.68964547",
"0.6739422",
"0.67058235",
"0.6680829",
"0.66706884",
"0.6661056",
"0.66548723",
"0.6608459",
"0.6563865",
"0.6560858",
"0.6558214",
"0.6519720... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.